@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/grid-layout/utils/grid.utils.mjs

@@ -0,0 +1,247 @@
+import { clamp } from 'lodash-es';
+import { GridCompactType, } from '../type';
+import { getPointerPageX, getPointerPageY } from './mouse.utils';
+import { compact, getFirstCollision, moveElement, } from './react-grid-layout.utils';
+function clampSize(size, min = 1, max = Infinity) {
+    return clamp(size, min || 1, max || Infinity);
+}
+export function trackById(_index, item) {
+    return item.id;
+}
+/**
+ * call react-grid-layout utils 'compact()' function and return the compacted layout.
+ */
+export function compactGridLayout(layout, compactType, cols) {
+    return (compact(layout, compactType, cols)
+        // Prune react-grid-layout compact extra properties.
+        .map(item => ({
+        id: item.id,
+        x: item.x,
+        y: item.y,
+        w: item.w,
+        h: item.h,
+        minW: item.minW,
+        minH: item.minH,
+        maxW: item.maxW,
+        maxH: item.maxH,
+    })));
+}
+// convert web page absolute position to grid layout location (used for locate last position)
+function screenXToGridX(screenXPos, cols, width, gutter) {
+    const widthMinusGutters = width - gutter * (cols - 1);
+    const itemWidth = widthMinusGutters / cols;
+    const widthMinusOneItem = width - itemWidth;
+    const colWidthWithGutter = widthMinusOneItem / (cols - 1);
+    return Math.round(screenXPos / colWidthWithGutter);
+}
+function screenYToGridY(screenYPos, rowHeight, gutter) {
+    return Math.round(screenYPos / (rowHeight + gutter));
+}
+// convert web page absolute size to grid layout size (used for locate last position)
+function screenWidthToGridWidth(gridScreenWidth, cols, width, gutter) {
+    const widthMinusGutters = width - gutter * (cols - 1);
+    const itemWidth = widthMinusGutters / cols;
+    const gridScreenWidthMinusFirst = gridScreenWidth - itemWidth;
+    return Math.round(gridScreenWidthMinusFirst / (itemWidth + gutter)) + 1;
+}
+function screenHeightToGridHeight(gridScreenHeight, rowHeight, gutter) {
+    const gridScreenHeightMinusFirst = gridScreenHeight - rowHeight;
+    return Math.round(gridScreenHeightMinusFirst / (rowHeight + gutter)) + 1;
+}
+/** Returns a Dictionary where the key is the id and the value is the change applied to that item. If no changes Dictionary is empty. */
+export function getGetGridLayoutDiff(gridLayoutA, gridLayoutB) {
+    const diff = {};
+    gridLayoutA.forEach(itemA => {
+        const itemB = gridLayoutB.find(_itemB => _itemB.id === itemA.id);
+        if (itemB != null) {
+            const posChanged = itemA.x !== itemB.x || itemA.y !== itemB.y;
+            const sizeChanged = itemA.w !== itemB.w || itemA.h !== itemB.h;
+            const change = posChanged && sizeChanged
+                ? 'moveresize'
+                : posChanged
+                    ? 'move'
+                    : sizeChanged
+                        ? 'resize'
+                        : null;
+            if (change) {
+                diff[itemB.id] = { change };
+            }
+        }
+    });
+    return diff;
+}
+// get the on-flight dragging item position and its last position(used for placeholder)
+export function gridItemDragging(gridItem, config, compactType, draggingData) {
+    const { pointerDownEvent, pointerDragEvent, gridElemClientRect, dragElemClientRect, scrollDifference, } = draggingData;
+    const gridItemId = gridItem.id;
+    const draggingElemPrevItem = config.layout.find(item => item.id === gridItemId);
+    const clientStartX = getPointerPageX(pointerDownEvent);
+    const clientStartY = getPointerPageY(pointerDownEvent);
+    const clientX = getPointerPageX(pointerDragEvent);
+    const clientY = getPointerPageY(pointerDragEvent);
+    const offsetX = clientStartX - dragElemClientRect.left;
+    const offsetY = clientStartY - dragElemClientRect.top;
+    // Grid element positions taking into account the possible scroll total difference from the beginning.
+    const gridElementLeftPosition = gridElemClientRect.left + scrollDifference.left;
+    const gridElementTopPosition = gridElemClientRect.top + scrollDifference.top;
+    // Calculate position relative to the grid element.
+    const gridRelXPos = clientX - gridElementLeftPosition - offsetX;
+    const gridRelYPos = clientY - gridElementTopPosition - offsetY;
+    // Get layout item position
+    const layoutItem = {
+        ...draggingElemPrevItem,
+        x: screenXToGridX(gridRelXPos, config.cols, gridElemClientRect.width, config.gutter),
+        y: screenYToGridY(gridRelYPos, config.rowHeight, config.gutter),
+    };
+    // correct the values if they overflow
+    layoutItem.x = Math.max(0, layoutItem.x);
+    layoutItem.y = Math.max(0, layoutItem.y);
+    if (layoutItem.x + layoutItem.w > config.cols) {
+        layoutItem.x = Math.max(0, config.cols - layoutItem.w);
+    }
+    // Parse to LayoutItem array data in order to use 'react.grid-layout' utils
+    const layoutItems = config.layout;
+    const draggedLayoutItem = layoutItems.find(item => item.id === gridItemId);
+    let newLayoutItems = moveElement(layoutItems, draggedLayoutItem, layoutItem.x, layoutItem.y, true, config.preventCollision, compactType, config.cols);
+    newLayoutItems = compact(newLayoutItems, compactType, config.cols);
+    const dragItem = {
+        ...draggingElemPrevItem,
+        // items layout boundary will changed by compactType, when vertical,we can let bottom grow. when horizontal,we let right and bottom grow.
+        // so, left and top will always bound to 0.
+        top: clampSize(gridRelYPos, 0, Infinity),
+        left: clampSize(gridRelXPos, 0, compactType === GridCompactType.VERTICAL
+            ? gridElemClientRect.width - dragElemClientRect.width
+            : Infinity),
+    };
+    return {
+        layout: newLayoutItems,
+        draggedItemPos: dragItem,
+    };
+}
+// eslint-disable-next-line sonarjs/cognitive-complexity
+export function gridItemResizing(gridItem, config, compactType, draggingData) {
+    const { pointerDownEvent, pointerDragEvent, gridElemClientRect, dragElemClientRect, scrollDifference, } = draggingData;
+    const gridItemId = gridItem.id;
+    // use page offset to avoid scrolling offset caused by page shrink
+    const clientStartX = getPointerPageX(pointerDownEvent);
+    const clientStartY = getPointerPageY(pointerDownEvent);
+    const clientX = getPointerPageX(pointerDragEvent);
+    const clientY = getPointerPageY(pointerDragEvent);
+    // get the difference between the mouseDown and on-flight mouseDragging.
+    const resizeElemOffsetX = clientX - clientStartX;
+    const resizeElemOffsetY = clientY - clientStartY;
+    const draggingElemPrevItem = config.layout.find(item => item.id === gridItemId);
+    const width = dragElemClientRect.width + resizeElemOffsetX - scrollDifference.left;
+    const height = dragElemClientRect.height + resizeElemOffsetY - scrollDifference.top;
+    // Get layout item grid position
+    const layoutItem = {
+        ...draggingElemPrevItem,
+        w: screenWidthToGridWidth(width, config.cols, gridElemClientRect.width, config.gutter),
+        h: screenHeightToGridHeight(height, config.rowHeight, config.gutter),
+    };
+    layoutItem.w = clampSize(layoutItem.w, gridItem.minW ?? layoutItem.minW, gridItem.maxW ?? layoutItem.maxW);
+    layoutItem.h = clampSize(layoutItem.h, gridItem.minH ?? layoutItem.minH, gridItem.maxH ?? layoutItem.maxH);
+    if (layoutItem.x + layoutItem.w > config.cols) {
+        layoutItem.w = Math.max(1, config.cols - layoutItem.x);
+    }
+    if (config.preventCollision) {
+        const maxW = layoutItem.w;
+        const maxH = layoutItem.h;
+        let colliding = hasCollision(config.layout, layoutItem);
+        let shrunkDimension;
+        while (colliding) {
+            shrunkDimension = getShrinkDimension(layoutItem, shrunkDimension);
+            layoutItem[shrunkDimension]--;
+            colliding = hasCollision(config.layout, layoutItem);
+        }
+        if (shrunkDimension === 'w') {
+            layoutItem.h = maxH;
+            colliding = hasCollision(config.layout, layoutItem);
+            while (colliding) {
+                layoutItem.h--;
+                colliding = hasCollision(config.layout, layoutItem);
+            }
+        }
+        if (shrunkDimension === 'h') {
+            layoutItem.w = maxW;
+            colliding = hasCollision(config.layout, layoutItem);
+            while (colliding) {
+                layoutItem.w--;
+                colliding = hasCollision(config.layout, layoutItem);
+            }
+        }
+    }
+    const newLayoutItems = config.layout.map(item => item.id === gridItemId ? layoutItem : item);
+    return {
+        layout: compact(newLayoutItems, compactType, config.cols),
+        draggedItemPos: {
+            top: dragElemClientRect.top - gridElemClientRect.top,
+            left: dragElemClientRect.left - gridElemClientRect.left,
+            // when vertical, make sure resizing not overflow right boundary
+            width: clampSize(width, 0, compactType === GridCompactType.VERTICAL
+                ? (gridElemClientRect.width * (config.cols - layoutItem.x)) /
+                    config.cols
+                : Infinity),
+            height,
+        },
+    };
+}
+function hasCollision(layout, layoutItem) {
+    return !!getFirstCollision(layout, layoutItem);
+}
+function getShrinkDimension(layoutItem, lastShrunk) {
+    if (layoutItem.h <= 1) {
+        return 'w';
+    }
+    if (layoutItem.w <= 1) {
+        return 'h';
+    }
+    return lastShrunk === 'w' ? 'h' : 'w';
+}
+/** Returns true if both item1 and item2 GridLayoutItems are equivalent. */
+export function isGridItemLayoutItemEqual(item1, item2) {
+    return (item1.id === item2.id &&
+        item1.x === item2.x &&
+        item1.y === item2.y &&
+        item1.w === item2.w &&
+        item1.h === item2.h);
+}
+export function getGridHeight(layout, rowHeight, gutter) {
+    return layout.reduce((acc, cur) => Math.max(acc, (cur.y + cur.h) * rowHeight + Math.max(cur.y + cur.h - 1, 0) * gutter), 0);
+}
+export function getDragResizeEventData(gridItem, layout) {
+    return {
+        layout,
+        layoutItem: layout.find(item => item.id === gridItem.id),
+        gridItemRef: gridItem,
+    };
+}
+export function layoutToRenderItems(config, width, layout) {
+    const { cols, rowHeight, layout: rawLayout, gutter } = config;
+    const widthWithoutGutter = width - Math.max(gutter * (cols - 1), 0);
+    const itemWidthPerColumn = widthWithoutGutter / cols;
+    const renderItems = {};
+    for (const item of layout ?? rawLayout) {
+        renderItems[item.id] = {
+            id: item.id,
+            top: item.y * rowHeight + gutter * item.y,
+            left: item.x * itemWidthPerColumn + gutter * item.x,
+            width: item.w * itemWidthPerColumn + gutter * Math.max(item.w - 1, 0),
+            height: item.h * rowHeight + gutter * Math.max(item.h - 1, 0),
+        };
+    }
+    return renderItems;
+}
+export function parseRenderItemToPixels(renderItem) {
+    return {
+        id: renderItem.id,
+        top: `${renderItem.top}px`,
+        left: `${renderItem.left}px`,
+        width: `${renderItem.width}px`,
+        height: `${renderItem.height}px`,
+    };
+}
+export function correctLayout(layout, cols = 12) {
+    return compactGridLayout(layout, 'vertical', cols);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.utils.js","sourceRoot":"","sources":["../../../../../../libs/common/src/grid-layout/utils/grid.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { clamp } from 'lodash-es';\n\nimport { Dictionary } from '../../public-api';\nimport { GridItemComponent } from '../components/grid-items/component';\nimport {\n  DragResizeEvent,\n  GridCfg,\n  GridCompactType,\n  GridItemClientRect,\n  GridItemDimension,\n  GridItemDraggingInfo,\n  GridItemRenderData,\n  GridLayout,\n  GridLayoutItem,\n} from '../type';\n\nimport { getPointerPageX, getPointerPageY } from './mouse.utils';\nimport {\n  compact,\n  CompactType,\n  getFirstCollision,\n  Layout,\n  LayoutItem,\n  moveElement,\n} from './react-grid-layout.utils';\n\nfunction clampSize(size: number, min = 1, max = Infinity) {\n  return clamp(size, min || 1, max || Infinity);\n}\n\nexport function trackById(_index: number, item: { id: string }) {\n  return item.id;\n}\n\n/**\n * call react-grid-layout utils 'compact()' function and return the compacted layout.\n */\nexport function compactGridLayout(\n  layout: GridLayout,\n  compactType: GridCompactType,\n  cols: number,\n): GridLayout {\n  return (\n    compact(layout, compactType, cols)\n      // Prune react-grid-layout compact extra properties.\n      .map(item => ({\n        id: item.id,\n        x: item.x,\n        y: item.y,\n        w: item.w,\n        h: item.h,\n        minW: item.minW,\n        minH: item.minH,\n        maxW: item.maxW,\n        maxH: item.maxH,\n      }))\n  );\n}\n\n// convert web page absolute position to grid layout location (used for locate last position)\nfunction screenXToGridX(\n  screenXPos: number,\n  cols: number,\n  width: number,\n  gutter: number,\n): number {\n  const widthMinusGutters = width - gutter * (cols - 1);\n  const itemWidth = widthMinusGutters / cols;\n  const widthMinusOneItem = width - itemWidth;\n  const colWidthWithGutter = widthMinusOneItem / (cols - 1);\n  return Math.round(screenXPos / colWidthWithGutter);\n}\n\nfunction screenYToGridY(\n  screenYPos: number,\n  rowHeight: number,\n  gutter: number,\n): number {\n  return Math.round(screenYPos / (rowHeight + gutter));\n}\n// convert web page absolute size to grid layout size (used for locate last position)\nfunction screenWidthToGridWidth(\n  gridScreenWidth: number,\n  cols: number,\n  width: number,\n  gutter: number,\n): number {\n  const widthMinusGutters = width - gutter * (cols - 1);\n  const itemWidth = widthMinusGutters / cols;\n  const gridScreenWidthMinusFirst = gridScreenWidth - itemWidth;\n  return Math.round(gridScreenWidthMinusFirst / (itemWidth + gutter)) + 1;\n}\n\nfunction screenHeightToGridHeight(\n  gridScreenHeight: number,\n  rowHeight: number,\n  gutter: number,\n): number {\n  const gridScreenHeightMinusFirst = gridScreenHeight - rowHeight;\n  return Math.round(gridScreenHeightMinusFirst / (rowHeight + gutter)) + 1;\n}\n\n/** Returns a Dictionary where the key is the id and the value is the change applied to that item. If no changes Dictionary is empty. */\nexport function getGetGridLayoutDiff(\n  gridLayoutA: GridLayoutItem[],\n  gridLayoutB: GridLayoutItem[],\n): Dictionary<{ change: 'move' | 'resize' | 'moveresize' }> {\n  const diff: Dictionary<{ change: 'move' | 'resize' | 'moveresize' }> = {};\n\n  gridLayoutA.forEach(itemA => {\n    const itemB = gridLayoutB.find(_itemB => _itemB.id === itemA.id);\n    if (itemB != null) {\n      const posChanged = itemA.x !== itemB.x || itemA.y !== itemB.y;\n      const sizeChanged = itemA.w !== itemB.w || itemA.h !== itemB.h;\n      const change: 'move' | 'resize' | 'moveresize' | null =\n        posChanged && sizeChanged\n          ? 'moveresize'\n          : posChanged\n          ? 'move'\n          : sizeChanged\n          ? 'resize'\n          : null;\n      if (change) {\n        diff[itemB.id] = { change };\n      }\n    }\n  });\n  return diff;\n}\n\n// get the on-flight dragging item position and its last position(used for placeholder)\nexport function gridItemDragging(\n  gridItem: GridItemComponent,\n  config: GridCfg,\n  compactType: CompactType,\n  draggingData: GridItemDraggingInfo,\n): { layout: GridLayoutItem[]; draggedItemPos: GridItemClientRect } {\n  const {\n    pointerDownEvent,\n    pointerDragEvent,\n    gridElemClientRect,\n    dragElemClientRect,\n    scrollDifference,\n  } = draggingData;\n\n  const gridItemId = gridItem.id;\n  const draggingElemPrevItem = config.layout.find(\n    item => item.id === gridItemId,\n  )!;\n\n  const clientStartX = getPointerPageX(pointerDownEvent);\n  const clientStartY = getPointerPageY(pointerDownEvent);\n  const clientX = getPointerPageX(pointerDragEvent);\n  const clientY = getPointerPageY(pointerDragEvent);\n\n  const offsetX = clientStartX - dragElemClientRect.left;\n  const offsetY = clientStartY - dragElemClientRect.top;\n\n  // Grid element positions taking into account the possible scroll total difference from the beginning.\n  const gridElementLeftPosition =\n    gridElemClientRect.left + scrollDifference.left;\n  const gridElementTopPosition = gridElemClientRect.top + scrollDifference.top;\n  // Calculate position relative to the grid element.\n  const gridRelXPos = clientX - gridElementLeftPosition - offsetX;\n\n  const gridRelYPos = clientY - gridElementTopPosition - offsetY;\n\n  // Get layout item position\n  const layoutItem: GridLayoutItem = {\n    ...draggingElemPrevItem,\n    x: screenXToGridX(\n      gridRelXPos,\n      config.cols,\n      gridElemClientRect.width,\n      config.gutter,\n    ),\n    y: screenYToGridY(gridRelYPos, config.rowHeight, config.gutter),\n  };\n\n  // correct the values if they overflow\n  layoutItem.x = Math.max(0, layoutItem.x);\n  layoutItem.y = Math.max(0, layoutItem.y);\n\n  if (layoutItem.x + layoutItem.w > config.cols) {\n    layoutItem.x = Math.max(0, config.cols - layoutItem.w);\n  }\n\n  // Parse to LayoutItem array data in order to use 'react.grid-layout' utils\n  const layoutItems: LayoutItem[] = config.layout;\n  const draggedLayoutItem: LayoutItem = layoutItems.find(\n    item => item.id === gridItemId,\n  )!;\n\n  let newLayoutItems: LayoutItem[] = moveElement(\n    layoutItems,\n    draggedLayoutItem,\n    layoutItem.x,\n    layoutItem.y,\n    true,\n    config.preventCollision,\n    compactType,\n    config.cols,\n  );\n\n  newLayoutItems = compact(newLayoutItems, compactType, config.cols);\n  const dragItem = {\n    ...draggingElemPrevItem,\n    // items layout boundary will changed by compactType, when vertical,we can let bottom grow. when horizontal,we let right and bottom grow.\n    // so, left and top will always bound to 0.\n    top: clampSize(gridRelYPos, 0, Infinity),\n    left: clampSize(\n      gridRelXPos,\n      0,\n      compactType === GridCompactType.VERTICAL\n        ? gridElemClientRect.width - dragElemClientRect.width\n        : Infinity,\n    ),\n  };\n  return {\n    layout: newLayoutItems,\n    draggedItemPos: dragItem,\n  };\n}\n\n// eslint-disable-next-line sonarjs/cognitive-complexity\nexport function gridItemResizing(\n  gridItem: GridItemComponent,\n  config: GridCfg,\n  compactType: CompactType,\n  draggingData: GridItemDraggingInfo,\n): { layout: GridLayoutItem[]; draggedItemPos: GridItemClientRect } {\n  const {\n    pointerDownEvent,\n    pointerDragEvent,\n    gridElemClientRect,\n    dragElemClientRect,\n    scrollDifference,\n  } = draggingData;\n  const gridItemId = gridItem.id;\n\n  // use page offset to avoid scrolling offset caused by page shrink\n  const clientStartX = getPointerPageX(pointerDownEvent);\n  const clientStartY = getPointerPageY(pointerDownEvent);\n  const clientX = getPointerPageX(pointerDragEvent);\n  const clientY = getPointerPageY(pointerDragEvent);\n\n  // get the difference between the mouseDown and on-flight mouseDragging.\n  const resizeElemOffsetX = clientX - clientStartX;\n  const resizeElemOffsetY = clientY - clientStartY;\n  const draggingElemPrevItem = config.layout.find(\n    item => item.id === gridItemId,\n  )!;\n  const width =\n    dragElemClientRect.width + resizeElemOffsetX - scrollDifference.left;\n  const height =\n    dragElemClientRect.height + resizeElemOffsetY - scrollDifference.top;\n\n  // Get layout item grid position\n  const layoutItem: GridLayoutItem = {\n    ...draggingElemPrevItem,\n    w: screenWidthToGridWidth(\n      width,\n      config.cols,\n      gridElemClientRect.width,\n      config.gutter,\n    ),\n    h: screenHeightToGridHeight(height, config.rowHeight, config.gutter),\n  };\n\n  layoutItem.w = clampSize(\n    layoutItem.w,\n    gridItem.minW ?? layoutItem.minW,\n    gridItem.maxW ?? layoutItem.maxW,\n  );\n  layoutItem.h = clampSize(\n    layoutItem.h,\n    gridItem.minH ?? layoutItem.minH,\n    gridItem.maxH ?? layoutItem.maxH,\n  );\n  if (layoutItem.x + layoutItem.w > config.cols) {\n    layoutItem.w = Math.max(1, config.cols - layoutItem.x);\n  }\n\n  if (config.preventCollision) {\n    const maxW = layoutItem.w;\n    const maxH = layoutItem.h;\n\n    let colliding = hasCollision(config.layout, layoutItem);\n    let shrunkDimension: GridItemDimension;\n\n    while (colliding) {\n      shrunkDimension = getShrinkDimension(layoutItem, shrunkDimension);\n      layoutItem[shrunkDimension]--;\n      colliding = hasCollision(config.layout, layoutItem);\n    }\n\n    if (shrunkDimension === 'w') {\n      layoutItem.h = maxH;\n\n      colliding = hasCollision(config.layout, layoutItem);\n      while (colliding) {\n        layoutItem.h--;\n        colliding = hasCollision(config.layout, layoutItem);\n      }\n    }\n    if (shrunkDimension === 'h') {\n      layoutItem.w = maxW;\n\n      colliding = hasCollision(config.layout, layoutItem);\n      while (colliding) {\n        layoutItem.w--;\n        colliding = hasCollision(config.layout, layoutItem);\n      }\n    }\n  }\n  const newLayoutItems: LayoutItem[] = config.layout.map(item =>\n    item.id === gridItemId ? layoutItem : item,\n  );\n  return {\n    layout: compact(newLayoutItems, compactType, config.cols),\n    draggedItemPos: {\n      top: dragElemClientRect.top - gridElemClientRect.top,\n      left: dragElemClientRect.left - gridElemClientRect.left,\n      // when vertical, make sure resizing not overflow right boundary\n      width: clampSize(\n        width,\n        0,\n        compactType === GridCompactType.VERTICAL\n          ? (gridElemClientRect.width * (config.cols - layoutItem.x)) /\n              config.cols\n          : Infinity,\n      ),\n      height,\n    },\n  };\n}\n\nfunction hasCollision(layout: Layout, layoutItem: LayoutItem): boolean {\n  return !!getFirstCollision(layout, layoutItem);\n}\n\nfunction getShrinkDimension(\n  layoutItem: GridLayoutItem,\n  lastShrunk: GridItemDimension,\n): GridItemDimension {\n  if (layoutItem.h <= 1) {\n    return 'w';\n  }\n  if (layoutItem.w <= 1) {\n    return 'h';\n  }\n\n  return lastShrunk === 'w' ? 'h' : 'w';\n}\n\n/** Returns true if both item1 and item2 GridLayoutItems are equivalent. */\nexport function isGridItemLayoutItemEqual(\n  item1: GridLayoutItem,\n  item2: GridLayoutItem,\n): boolean {\n  return (\n    item1.id === item2.id &&\n    item1.x === item2.x &&\n    item1.y === item2.y &&\n    item1.w === item2.w &&\n    item1.h === item2.h\n  );\n}\n\nexport function getGridHeight(\n  layout: GridLayout,\n  rowHeight: number,\n  gutter: number,\n): number {\n  return layout.reduce(\n    (acc, cur) =>\n      Math.max(\n        acc,\n        (cur.y + cur.h) * rowHeight + Math.max(cur.y + cur.h - 1, 0) * gutter,\n      ),\n    0,\n  );\n}\nexport function getDragResizeEventData(\n  gridItem: GridItemComponent,\n  layout: GridLayout,\n): DragResizeEvent {\n  return {\n    layout,\n    layoutItem: layout.find(item => item.id === gridItem.id)!,\n    gridItemRef: gridItem,\n  };\n}\n\nexport function layoutToRenderItems(\n  config: GridCfg,\n  width: number,\n  layout?: GridLayout,\n): Dictionary<GridItemRenderData> {\n  const { cols, rowHeight, layout: rawLayout, gutter } = config;\n  const widthWithoutGutter = width - Math.max(gutter * (cols - 1), 0);\n  const itemWidthPerColumn = widthWithoutGutter / cols;\n  const renderItems: Dictionary<GridItemRenderData> = {};\n\n  for (const item of layout ?? rawLayout) {\n    renderItems[item.id] = {\n      id: item.id,\n      top: item.y * rowHeight + gutter * item.y,\n      left: item.x * itemWidthPerColumn + gutter * item.x,\n      width: item.w * itemWidthPerColumn + gutter * Math.max(item.w - 1, 0),\n      height: item.h * rowHeight + gutter * Math.max(item.h - 1, 0),\n    };\n  }\n  return renderItems;\n}\n\nexport function parseRenderItemToPixels(\n  renderItem: GridItemRenderData,\n): GridItemRenderData<string> {\n  return {\n    id: renderItem.id,\n    top: `${renderItem.top}px`,\n    left: `${renderItem.left}px`,\n    width: `${renderItem.width}px`,\n    height: `${renderItem.height}px`,\n  };\n}\n\nexport function correctLayout(layout: GridLayout, cols = 12) {\n  return compactGridLayout(layout, 'vertical', cols);\n}\n"]}

package/esm2022/grid-layout/utils/mouse.utils.mjs

@@ -0,0 +1,50 @@
+import { filter, fromEvent } from 'rxjs';
+var MOUSE_EVENT_KEY;
+(function (MOUSE_EVENT_KEY) {
+    MOUSE_EVENT_KEY[MOUSE_EVENT_KEY["LEFT"] = 0] = "LEFT";
+    MOUSE_EVENT_KEY[MOUSE_EVENT_KEY["WHEEL"] = 1] = "WHEEL";
+    MOUSE_EVENT_KEY[MOUSE_EVENT_KEY["RIGHT"] = 2] = "RIGHT";
+})(MOUSE_EVENT_KEY || (MOUSE_EVENT_KEY = {}));
+const activeEventListenerOptions = { passive: false };
+/**
+ * Emits when a 'mousemove' event gets fired.
+ * @param element, html element where to  listen the events.
+ */
+export function getMouseMove$(element) {
+    return fromEvent(element, 'mousemove', activeEventListenerOptions);
+}
+/**
+ * Emits when a mousedown emits..
+ * @param element, html element where to  listen the events.
+ */
+export function getMouseClick$(element) {
+    return fromEvent(element, 'click');
+}
+/**
+ * Emits when a mousedown emits..
+ * @param element, html element where to  listen the events.
+ */
+export function getMouseDown$(element) {
+    return fromEvent(element, 'mousedown', activeEventListenerOptions).pipe(filter((mouseEvent) => mouseEvent.button === MOUSE_EVENT_KEY.LEFT &&
+        mouseEvent.currentTarget === element));
+}
+/**
+ * Emits when a there is a 'mouseup'.
+ * @param element, html element where to  listen the events.
+ */
+export function getMouseEnd$(element) {
+    return fromEvent(element, 'mouseup');
+}
+export function getPointerPageX(event) {
+    return event.pageX;
+}
+export function getPointerPageY(event) {
+    return event.pageY;
+}
+// 判定相对于某个特定事件（如点击）发生时，鼠标移动距离超过 threshold ，一般用于设置拖拽容忍
+export function accessPointerMoveThreshold(sourceEvt, moveEvent, threshold) {
+    const distanceX = Math.abs(sourceEvt.clientX - moveEvent.clientX);
+    const distanceY = Math.abs(sourceEvt.clientY - moveEvent.clientY);
+    return distanceX + distanceY >= threshold;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/grid-layout/utils/operator.mjs

@@ -0,0 +1,6 @@
+import { Observable } from 'rxjs';
+// run source observable outside the zone
+export function runOutsideZone$(zone) {
+    return (source) => new Observable(observer => zone.runOutsideAngular(() => source.subscribe(observer)));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlcmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvZ3JpZC1sYXlvdXQvdXRpbHMvb3BlcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUVsQyx5Q0FBeUM7QUFDekMsTUFBTSxVQUFVLGVBQWUsQ0FBSSxJQUFZO0lBQzdDLE9BQU8sQ0FBQyxNQUFxQixFQUFFLEVBQUUsQ0FDL0IsSUFBSSxVQUFVLENBQUksUUFBUSxDQUFDLEVBQUUsQ0FDM0IsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FDekQsQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ1pvbmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuLy8gcnVuIHNvdXJjZSBvYnNlcnZhYmxlIG91dHNpZGUgdGhlIHpvbmVcbmV4cG9ydCBmdW5jdGlvbiBydW5PdXRzaWRlWm9uZSQ8VD4oem9uZTogTmdab25lKSB7XG4gIHJldHVybiAoc291cmNlOiBPYnNlcnZhYmxlPFQ+KSA9PlxuICAgIG5ldyBPYnNlcnZhYmxlPFQ+KG9ic2VydmVyID0+XG4gICAgICB6b25lLnJ1bk91dHNpZGVBbmd1bGFyKCgpID0+IHNvdXJjZS5zdWJzY3JpYmUob2JzZXJ2ZXIpKSxcbiAgICApO1xufVxuIl19