impact-ui 4.0.0-alpha.2 → 4.0.0-alpha.3

package/dist/node_modules/@dnd-kit/sortable/dist/sortable.esm.js

@@ -1,418 +0,0 @@
-import React__default, { useMemo, useRef, useEffect, useContext, useState } from "react";
-import { useDndContext, useDroppable, useDraggable, getClientRect, KeyboardCode } from "../../core/dist/core.esm.js";
-import { useUniqueId, useIsomorphicLayoutEffect, useCombinedRefs, isKeyboardEvent, CSS } from "../../utilities/dist/utilities.esm.js";
-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
-  };
-};
-const ID_PREFIX = "Sortable";
-const Context = /* @__PURE__ */ React__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
-  } = useDndContext();
-  const containerId = useUniqueId(ID_PREFIX, id);
-  const useDragOverlay = Boolean(dragOverlay.rect !== null);
-  const items = 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 = useRef(items);
-  const itemsHaveChanged = !itemsEqual(items, previousItemsRef.current);
-  const disableTransforms = overIndex !== -1 && activeIndex === -1 || itemsHaveChanged;
-  const disabled = normalizeDisabled(disabledProp);
-  useIsomorphicLayoutEffect(() => {
-    if (itemsHaveChanged && isDragging) {
-      measureDroppableContainers(items);
-    }
-  }, [itemsHaveChanged, items, isDragging, measureDroppableContainers]);
-  useEffect(() => {
-    previousItemsRef.current = items;
-  }, [items]);
-  const contextValue = 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.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__ */ CSS.Transition.toString({
-  property: transitionProperty,
-  duration: 0,
-  easing: "linear"
-});
-const defaultAttributes = {
-  roleDescription: "sortable"
-};
-function useDerivedTransform(_ref) {
-  let {
-    disabled,
-    index,
-    node,
-    rect
-  } = _ref;
-  const [derivedTransform, setDerivedtransform] = useState(null);
-  const previousIndex = useRef(index);
-  useIsomorphicLayoutEffect(() => {
-    if (!disabled && index !== previousIndex.current && node.current) {
-      const initial = rect.current;
-      if (initial) {
-        const current = 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]);
-  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
-  } = useContext(Context);
-  const disabled = normalizeLocalDisabled(localDisabled, globalDisabled);
-  const index = items.indexOf(id);
-  const data = useMemo(() => ({
-    sortable: {
-      containerId,
-      index,
-      items
-    },
-    ...customData
-  }), [containerId, customData, index, items]);
-  const itemsAfterCurrentSortable = useMemo(() => items.slice(items.indexOf(id)), [items, id]);
-  const {
-    rect,
-    node,
-    isOver,
-    setNodeRef: setDroppableNodeRef
-  } = useDroppable({
-    id,
-    data,
-    disabled: disabled.droppable,
-    resizeObserverConfig: {
-      updateMeasurementsFor: itemsAfterCurrentSortable,
-      ...resizeObserverConfig
-    }
-  });
-  const {
-    active,
-    activatorEvent,
-    activeNodeRect,
-    attributes,
-    setNodeRef: setDraggableNodeRef,
-    listeners,
-    isDragging,
-    over,
-    setActivatorNodeRef,
-    transform
-  } = useDraggable({
-    id,
-    data,
-    attributes: {
-      ...defaultAttributes,
-      ...userDefinedAttributes
-    },
-    disabled: disabled.draggable
-  });
-  const setNodeRef = 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 = 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
-  });
-  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]);
-  useEffect(() => {
-    if (activeId === previous.current.activeId) {
-      return;
-    }
-    if (activeId != null && previous.current.activeId == null) {
-      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 && !isKeyboardEvent(activatorEvent) || !transition) {
-      return void 0;
-    }
-    if (isSorting || shouldAnimateLayoutChanges) {
-      return CSS.Transition.toString({
-        ...transition,
-        property: transitionProperty
-      });
-    }
-    return void 0;
-  }
-}
-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
-  };
-}
-[KeyboardCode.Down, KeyboardCode.Right, KeyboardCode.Up, KeyboardCode.Left];
-export {
-  SortableContext,
-  arrayMove,
-  defaultAnimateLayoutChanges,
-  defaultNewIndexGetter,
-  rectSortingStrategy,
-  useSortable
-};

package/dist/node_modules/@dnd-kit/utilities/dist/utilities.esm.js

@@ -1,301 +0,0 @@
-import { useRef, useMemo, useLayoutEffect, useEffect, useCallback } from "react";
-function useCombinedRefs() {
-  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
-    refs[_key] = arguments[_key];
-  }
-  return useMemo(
-    () => (node) => {
-      refs.forEach((ref) => ref(node));
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    refs
-  );
-}
-const canUseDOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
-function isWindow(element) {
-  const elementString = Object.prototype.toString.call(element);
-  return elementString === "[object Window]" || // In Electron context the Window object serializes to [object global]
-  elementString === "[object global]";
-}
-function isNode(node) {
-  return "nodeType" in node;
-}
-function getWindow(target) {
-  var _target$ownerDocument, _target$ownerDocument2;
-  if (!target) {
-    return window;
-  }
-  if (isWindow(target)) {
-    return target;
-  }
-  if (!isNode(target)) {
-    return window;
-  }
-  return (_target$ownerDocument = (_target$ownerDocument2 = target.ownerDocument) == null ? void 0 : _target$ownerDocument2.defaultView) != null ? _target$ownerDocument : window;
-}
-function isDocument(node) {
-  const {
-    Document
-  } = getWindow(node);
-  return node instanceof Document;
-}
-function isHTMLElement(node) {
-  if (isWindow(node)) {
-    return false;
-  }
-  return node instanceof getWindow(node).HTMLElement;
-}
-function isSVGElement(node) {
-  return node instanceof getWindow(node).SVGElement;
-}
-function getOwnerDocument(target) {
-  if (!target) {
-    return document;
-  }
-  if (isWindow(target)) {
-    return target.document;
-  }
-  if (!isNode(target)) {
-    return document;
-  }
-  if (isDocument(target)) {
-    return target;
-  }
-  if (isHTMLElement(target) || isSVGElement(target)) {
-    return target.ownerDocument;
-  }
-  return document;
-}
-const useIsomorphicLayoutEffect = canUseDOM ? useLayoutEffect : useEffect;
-function useEvent(handler) {
-  const handlerRef = useRef(handler);
-  useIsomorphicLayoutEffect(() => {
-    handlerRef.current = handler;
-  });
-  return useCallback(function() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return handlerRef.current == null ? void 0 : handlerRef.current(...args);
-  }, []);
-}
-function useInterval() {
-  const intervalRef = useRef(null);
-  const set = useCallback((listener, duration) => {
-    intervalRef.current = setInterval(listener, duration);
-  }, []);
-  const clear = useCallback(() => {
-    if (intervalRef.current !== null) {
-      clearInterval(intervalRef.current);
-      intervalRef.current = null;
-    }
-  }, []);
-  return [set, clear];
-}
-function useLatestValue(value, dependencies) {
-  if (dependencies === void 0) {
-    dependencies = [value];
-  }
-  const valueRef = useRef(value);
-  useIsomorphicLayoutEffect(() => {
-    if (valueRef.current !== value) {
-      valueRef.current = value;
-    }
-  }, dependencies);
-  return valueRef;
-}
-function useLazyMemo(callback, dependencies) {
-  const valueRef = useRef();
-  return useMemo(
-    () => {
-      const newValue = callback(valueRef.current);
-      valueRef.current = newValue;
-      return newValue;
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [...dependencies]
-  );
-}
-function useNodeRef(onChange) {
-  const onChangeHandler = useEvent(onChange);
-  const node = useRef(null);
-  const setNodeRef = useCallback(
-    (element) => {
-      if (element !== node.current) {
-        onChangeHandler == null ? void 0 : onChangeHandler(element, node.current);
-      }
-      node.current = element;
-    },
-    //eslint-disable-next-line
-    []
-  );
-  return [node, setNodeRef];
-}
-function usePrevious(value) {
-  const ref = useRef();
-  useEffect(() => {
-    ref.current = value;
-  }, [value]);
-  return ref.current;
-}
-let ids = {};
-function useUniqueId(prefix, value) {
-  return useMemo(() => {
-    if (value) {
-      return value;
-    }
-    const id = ids[prefix] == null ? 0 : ids[prefix] + 1;
-    ids[prefix] = id;
-    return prefix + "-" + id;
-  }, [prefix, value]);
-}
-function createAdjustmentFn(modifier) {
-  return function(object) {
-    for (var _len = arguments.length, adjustments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      adjustments[_key - 1] = arguments[_key];
-    }
-    return adjustments.reduce((accumulator, adjustment) => {
-      const entries = Object.entries(adjustment);
-      for (const [key, valueAdjustment] of entries) {
-        const value = accumulator[key];
-        if (value != null) {
-          accumulator[key] = value + modifier * valueAdjustment;
-        }
-      }
-      return accumulator;
-    }, {
-      ...object
-    });
-  };
-}
-const add = /* @__PURE__ */ createAdjustmentFn(1);
-const subtract = /* @__PURE__ */ createAdjustmentFn(-1);
-function hasViewportRelativeCoordinates(event) {
-  return "clientX" in event && "clientY" in event;
-}
-function isKeyboardEvent(event) {
-  if (!event) {
-    return false;
-  }
-  const {
-    KeyboardEvent
-  } = getWindow(event.target);
-  return KeyboardEvent && event instanceof KeyboardEvent;
-}
-function isTouchEvent(event) {
-  if (!event) {
-    return false;
-  }
-  const {
-    TouchEvent
-  } = getWindow(event.target);
-  return TouchEvent && event instanceof TouchEvent;
-}
-function getEventCoordinates(event) {
-  if (isTouchEvent(event)) {
-    if (event.touches && event.touches.length) {
-      const {
-        clientX: x,
-        clientY: y
-      } = event.touches[0];
-      return {
-        x,
-        y
-      };
-    } else if (event.changedTouches && event.changedTouches.length) {
-      const {
-        clientX: x,
-        clientY: y
-      } = event.changedTouches[0];
-      return {
-        x,
-        y
-      };
-    }
-  }
-  if (hasViewportRelativeCoordinates(event)) {
-    return {
-      x: event.clientX,
-      y: event.clientY
-    };
-  }
-  return null;
-}
-const CSS = /* @__PURE__ */ Object.freeze({
-  Translate: {
-    toString(transform) {
-      if (!transform) {
-        return;
-      }
-      const {
-        x,
-        y
-      } = transform;
-      return "translate3d(" + (x ? Math.round(x) : 0) + "px, " + (y ? Math.round(y) : 0) + "px, 0)";
-    }
-  },
-  Scale: {
-    toString(transform) {
-      if (!transform) {
-        return;
-      }
-      const {
-        scaleX,
-        scaleY
-      } = transform;
-      return "scaleX(" + scaleX + ") scaleY(" + scaleY + ")";
-    }
-  },
-  Transform: {
-    toString(transform) {
-      if (!transform) {
-        return;
-      }
-      return [CSS.Translate.toString(transform), CSS.Scale.toString(transform)].join(" ");
-    }
-  },
-  Transition: {
-    toString(_ref) {
-      let {
-        property,
-        duration,
-        easing
-      } = _ref;
-      return property + " " + duration + "ms " + easing;
-    }
-  }
-});
-const SELECTOR = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
-function findFirstFocusableNode(element) {
-  if (element.matches(SELECTOR)) {
-    return element;
-  }
-  return element.querySelector(SELECTOR);
-}
-export {
-  CSS,
-  add,
-  canUseDOM,
-  findFirstFocusableNode,
-  getEventCoordinates,
-  getOwnerDocument,
-  getWindow,
-  hasViewportRelativeCoordinates,
-  isDocument,
-  isHTMLElement,
-  isKeyboardEvent,
-  isNode,
-  isSVGElement,
-  isTouchEvent,
-  isWindow,
-  subtract,
-  useCombinedRefs,
-  useEvent,
-  useInterval,
-  useIsomorphicLayoutEffect,
-  useLatestValue,
-  useLazyMemo,
-  useNodeRef,
-  usePrevious,
-  useUniqueId
-};