@idraw/core 0.4.0-beta.4 → 0.4.0-beta.41

package/dist/esm/middleware/selector/pattern/icon-rotate.d.ts

@@ -0,0 +1,4 @@
+import type { Element } from '@idraw/types';
+export declare const createIconRotate: (opts?: {
+    fill?: string;
+}) => Element<"path", Record<string, any>>;

package/dist/esm/middleware/selector/pattern/icon-rotate.js

@@ -0,0 +1,88 @@
+import { createUUID } from '@idraw/util';
+export const createIconRotate = (opts) => {
+    const iconRotate = {
+        uuid: createUUID(),
+        type: 'path',
+        x: 0,
+        y: 0,
+        w: 200,
+        h: 200,
+        detail: Object.assign({ commands: [
+                {
+                    type: 'M',
+                    params: [512, 0]
+                },
+                {
+                    type: 'c',
+                    params: [282.8, 0, 512, 229.2, 512, 512]
+                },
+                {
+                    type: 's',
+                    params: [-229.2, 512, -512, 512]
+                },
+                {
+                    type: 'S',
+                    params: [0, 794.8, 0, 512, 229.2, 0, 512, 0]
+                },
+                {
+                    type: 'z',
+                    params: []
+                },
+                {
+                    type: 'm',
+                    params: [309.8, 253.8]
+                },
+                {
+                    type: 'c',
+                    params: [0, -10.5, -6.5, -19.8, -15.7, -23.8, -9.7, -4, -21, -2, -28.2, 5.6]
+                },
+                {
+                    type: 'l',
+                    params: [-52.5, 52]
+                },
+                {
+                    type: 'c',
+                    params: [
+                        -56.9, -53.7, -133.9, -85.5, -213.4, -85.5, -170.7, 0, -309.8, 139.2, -309.8, 309.8, 0, 170.6, 139.2, 309.8, 309.8, 309.8, 92.4, 0, 179.5, -40.8,
+                        238.4, -111.8, 4, -5.2, 4, -12.9, -0.8, -17.3
+                    ]
+                },
+                {
+                    type: 'L',
+                    params: [694.3, 637]
+                },
+                {
+                    type: 'c',
+                    params: [
+                        -2.8, -2.4, -6.5, -3.6, -10.1, -3.6, -3.6, 0.4, -7.3, 2, -9.3, 4.8, -39.5, 51.2, -98.8, 80.3, -163, 80.3, -113.8, 0, -206.5, -92.8, -206.5, -206.5,
+                        0, -113.8, 92.8, -206.5, 206.5, -206.5, 52.8, 0, 102.9, 20.2, 140.8, 55.3
+                    ]
+                },
+                {
+                    type: 'L',
+                    params: [597, 416.5]
+                },
+                {
+                    type: 'c',
+                    params: [-7.7, 7.3, -9.7, 18.6, -5.6, 27.9, 4, 9.7, 13.3, 16.1, 23.8, 16.1]
+                },
+                {
+                    type: 'H',
+                    params: [796]
+                },
+                {
+                    type: 'c',
+                    params: [14.1, 0, 25.8, -11.7, 25.8, -25.8]
+                },
+                {
+                    type: 'V',
+                    params: [253.8]
+                },
+                {
+                    type: 'z',
+                    params: []
+                }
+            ], fill: '#2c2c2c', stroke: 'transparent', strokeWidth: 0, originX: 0, originY: 0, originW: 1024, originH: 1024, opacity: 1 }, opts)
+    };
+    return iconRotate;
+};

package/dist/esm/middleware/selector/pattern/index.d.ts

@@ -0,0 +1,8 @@
+import type { ViewContext2D } from '@idraw/types';
+export declare function createRotateControllerPattern(opts: {
+    fill: string;
+    devicePixelRatio: number;
+}): {
+    context2d: ViewContext2D;
+    fill: string;
+};

package/dist/esm/middleware/selector/pattern/index.js

@@ -0,0 +1,38 @@
+import { createOffscreenContext2D } from '@idraw/util';
+import { drawElement } from '@idraw/renderer';
+import { createIconRotate } from './icon-rotate';
+export function createRotateControllerPattern(opts) {
+    const { fill, devicePixelRatio } = opts;
+    const iconRotate = createIconRotate({ fill });
+    const { w, h } = iconRotate;
+    const context2d = createOffscreenContext2D({
+        width: w,
+        height: h,
+        devicePixelRatio
+    });
+    drawElement(context2d, iconRotate, {
+        loader: undefined,
+        viewScaleInfo: {
+            scale: 1,
+            offsetTop: 0,
+            offsetBottom: 0,
+            offsetLeft: 0,
+            offsetRight: 0
+        },
+        viewSizeInfo: {
+            width: w,
+            height: h,
+            devicePixelRatio,
+            contextWidth: w,
+            contextHeight: h
+        },
+        parentElementSize: {
+            x: 0,
+            y: 0,
+            w,
+            h
+        },
+        parentOpacity: 1
+    });
+    return { context2d, fill };
+}

package/dist/esm/middleware/selector/reference.d.ts

@@ -0,0 +1,13 @@
+import type { Data, Element, PointSize, ViewScaleInfo, ViewSizeInfo, ViewCalculator } from '@idraw/types';
+export declare function calcReferenceInfo(uuid: string, opts: {
+    data: Data;
+    groupQueue: Element<'group'>[];
+    calculator: ViewCalculator;
+    viewScaleInfo: ViewScaleInfo;
+    viewSizeInfo: ViewSizeInfo;
+}): {
+    offsetX: number | null;
+    offsetY: number | null;
+    yLines: PointSize[][];
+    xLines: PointSize[][];
+} | null;

package/dist/esm/middleware/selector/reference.js

@@ -0,0 +1,267 @@
+import { is } from '@idraw/util';
+const unitSize = 2;
+function getViewBoxInfo(rectInfo) {
+    const boxInfo = {
+        minX: rectInfo.topLeft.x,
+        minY: rectInfo.topLeft.y,
+        maxX: rectInfo.bottomRight.x,
+        maxY: rectInfo.bottomRight.y,
+        midX: rectInfo.center.x,
+        midY: rectInfo.center.y
+    };
+    return boxInfo;
+}
+const getClosestNumInSortedKeys = (sortedKeys, target) => {
+    if (sortedKeys.length === 0) {
+        throw null;
+    }
+    if (sortedKeys.length === 1) {
+        return sortedKeys[0];
+    }
+    let left = 0;
+    let right = sortedKeys.length - 1;
+    while (left <= right) {
+        const mid = Math.floor((left + right) / 2);
+        if (sortedKeys[mid] === target) {
+            return sortedKeys[mid];
+        }
+        else if (sortedKeys[mid] < target) {
+            left = mid + 1;
+        }
+        else {
+            right = mid - 1;
+        }
+    }
+    if (left >= sortedKeys.length) {
+        return sortedKeys[right];
+    }
+    if (right < 0) {
+        return sortedKeys[left];
+    }
+    return Math.abs(sortedKeys[right] - target) <= Math.abs(sortedKeys[left] - target) ? sortedKeys[right] : sortedKeys[left];
+};
+const isEqualNum = (a, b) => Math.abs(a - b) < 0.00001;
+export function calcReferenceInfo(uuid, opts) {
+    var _a, _b;
+    const { data, groupQueue, calculator, viewScaleInfo, viewSizeInfo } = opts;
+    let targetElements = data.elements || [];
+    if ((groupQueue === null || groupQueue === void 0 ? void 0 : groupQueue.length) > 0) {
+        targetElements = ((_b = (_a = groupQueue[groupQueue.length - 1]) === null || _a === void 0 ? void 0 : _a.detail) === null || _b === void 0 ? void 0 : _b.children) || [];
+    }
+    const siblingViewRectInfoList = [];
+    targetElements.forEach((elem) => {
+        if (elem.uuid !== uuid) {
+            const info = calculator.calcViewRectInfoFromRange(elem.uuid, { checkVisible: true, viewScaleInfo, viewSizeInfo });
+            if (info) {
+                siblingViewRectInfoList.push(info);
+            }
+        }
+    });
+    const targetRectInfo = calculator.calcViewRectInfoFromRange(uuid, { viewScaleInfo, viewSizeInfo });
+    if (!targetRectInfo) {
+        return null;
+    }
+    const vTargetLineDotMap = {};
+    const hTargetLineDotMap = {};
+    const vRefLineDotMap = {};
+    const hRefLineDotMap = {};
+    const vHelperLineDotMapList = [];
+    const hHelperLineDotMapList = [];
+    let sortedRefXKeys = [];
+    let sortedRefYKeys = [];
+    const targetBox = getViewBoxInfo(targetRectInfo);
+    vTargetLineDotMap[targetBox.minX] = [targetBox.minY, targetBox.midY, targetBox.maxY];
+    vTargetLineDotMap[targetBox.midX] = [targetBox.minY, targetBox.midY, targetBox.maxY];
+    vTargetLineDotMap[targetBox.maxX] = [targetBox.minY, targetBox.midY, targetBox.maxY];
+    hTargetLineDotMap[targetBox.minY] = [targetBox.minX, targetBox.midX, targetBox.maxX];
+    hTargetLineDotMap[targetBox.midY] = [targetBox.minX, targetBox.midX, targetBox.maxX];
+    hTargetLineDotMap[targetBox.maxY] = [targetBox.minX, targetBox.midX, targetBox.maxX];
+    siblingViewRectInfoList.forEach((info) => {
+        const box = getViewBoxInfo(info);
+        if (!vRefLineDotMap[box.minX]) {
+            vRefLineDotMap[box.minX] = [];
+        }
+        if (!vRefLineDotMap[box.midX]) {
+            vRefLineDotMap[box.midX] = [];
+        }
+        if (!vRefLineDotMap[box.maxX]) {
+            vRefLineDotMap[box.maxX] = [];
+        }
+        if (!hRefLineDotMap[box.minY]) {
+            hRefLineDotMap[box.minY] = [];
+        }
+        if (!hRefLineDotMap[box.midY]) {
+            hRefLineDotMap[box.midY] = [];
+        }
+        if (!hRefLineDotMap[box.maxY]) {
+            hRefLineDotMap[box.maxY] = [];
+        }
+        vRefLineDotMap[box.minX] = [box.minY, box.midY, box.maxY];
+        vRefLineDotMap[box.midX] = [box.minY, box.midY, box.maxY];
+        vRefLineDotMap[box.maxX] = [box.minY, box.midY, box.maxY];
+        sortedRefXKeys.push(box.minX);
+        sortedRefXKeys.push(box.midX);
+        sortedRefXKeys.push(box.maxX);
+        hRefLineDotMap[box.minY] = [box.minX, box.midX, box.maxX];
+        hRefLineDotMap[box.midY] = [box.minX, box.midX, box.maxX];
+        hRefLineDotMap[box.maxY] = [box.minX, box.midX, box.maxX];
+        sortedRefYKeys.push(box.minY);
+        sortedRefYKeys.push(box.midY);
+        sortedRefYKeys.push(box.maxY);
+    });
+    sortedRefXKeys = sortedRefXKeys.sort((a, b) => a - b);
+    sortedRefYKeys = sortedRefYKeys.sort((a, b) => a - b);
+    let offsetX = null;
+    let offsetY = null;
+    let closestMinX = null;
+    let closestMidX = null;
+    let closestMaxX = null;
+    let closestMinY = null;
+    let closestMidY = null;
+    let closestMaxY = null;
+    if (sortedRefXKeys.length > 0) {
+        closestMinX = getClosestNumInSortedKeys(sortedRefXKeys, targetBox.minX);
+        closestMidX = getClosestNumInSortedKeys(sortedRefXKeys, targetBox.midX);
+        closestMaxX = getClosestNumInSortedKeys(sortedRefXKeys, targetBox.maxX);
+        const distMinX = Math.abs(closestMinX - targetBox.minX);
+        const distMidX = Math.abs(closestMidX - targetBox.midX);
+        const distMaxX = Math.abs(closestMaxX - targetBox.maxX);
+        const closestXDist = Math.min(distMinX, distMidX, distMaxX);
+        if (closestXDist <= unitSize / viewScaleInfo.scale) {
+            if (isEqualNum(closestXDist, distMinX)) {
+                offsetX = closestMinX - targetBox.minX;
+            }
+            else if (isEqualNum(closestXDist, distMidX)) {
+                offsetX = closestMidX - targetBox.midX;
+            }
+            else if (isEqualNum(closestXDist, distMaxX)) {
+                offsetX = closestMaxX - targetBox.maxX;
+            }
+        }
+    }
+    if (sortedRefYKeys.length > 0) {
+        closestMinY = getClosestNumInSortedKeys(sortedRefYKeys, targetBox.minY);
+        closestMidY = getClosestNumInSortedKeys(sortedRefYKeys, targetBox.midY);
+        closestMaxY = getClosestNumInSortedKeys(sortedRefYKeys, targetBox.maxY);
+        const distMinY = Math.abs(closestMinY - targetBox.minY);
+        const distMidY = Math.abs(closestMidY - targetBox.midY);
+        const distMaxY = Math.abs(closestMaxY - targetBox.maxY);
+        const closestYDist = Math.min(distMinY, distMidY, distMaxY);
+        if (closestYDist <= unitSize / viewScaleInfo.scale) {
+            if (isEqualNum(closestYDist, distMinY)) {
+                offsetY = closestMinY - targetBox.minY;
+            }
+            else if (isEqualNum(closestYDist, distMidY)) {
+                offsetY = closestMidY - targetBox.midY;
+            }
+            else if (isEqualNum(closestYDist, distMaxY)) {
+                offsetY = closestMaxY - targetBox.maxY;
+            }
+        }
+    }
+    const newTargetBox = Object.assign({}, targetBox);
+    if (offsetX !== null) {
+        newTargetBox.minX += offsetX;
+        newTargetBox.midX += offsetX;
+        newTargetBox.maxX += offsetX;
+    }
+    if (offsetY !== null) {
+        newTargetBox.minY += offsetY;
+        newTargetBox.midY += offsetY;
+        newTargetBox.maxY += offsetY;
+    }
+    if (is.x(offsetX) && offsetX !== null && closestMinX !== null && closestMidX !== null && closestMaxX !== null) {
+        if (isEqualNum(offsetX, closestMinX - targetBox.minX)) {
+            const vLine = {
+                x: closestMinX,
+                yList: []
+            };
+            vLine.yList.push(newTargetBox.minY);
+            vLine.yList.push(newTargetBox.maxY);
+            vLine.yList.push(...((hRefLineDotMap === null || hRefLineDotMap === void 0 ? void 0 : hRefLineDotMap[closestMinX]) || []));
+            vHelperLineDotMapList.push(vLine);
+        }
+        if (isEqualNum(offsetX, closestMidX - targetBox.minX)) {
+            const vLine = {
+                x: closestMidX,
+                yList: []
+            };
+            vLine.yList.push(newTargetBox.minY);
+            vLine.yList.push(newTargetBox.maxY);
+            vLine.yList.push(...((hRefLineDotMap === null || hRefLineDotMap === void 0 ? void 0 : hRefLineDotMap[closestMidX]) || []));
+            vHelperLineDotMapList.push(vLine);
+        }
+        if (isEqualNum(offsetX, closestMaxX - targetBox.minX)) {
+            const vLine = {
+                x: closestMaxX,
+                yList: []
+            };
+            vLine.yList.push(newTargetBox.minY);
+            vLine.yList.push(newTargetBox.maxY);
+            vLine.yList.push(...((hRefLineDotMap === null || hRefLineDotMap === void 0 ? void 0 : hRefLineDotMap[closestMaxX]) || []));
+            vHelperLineDotMapList.push(vLine);
+        }
+    }
+    if (is.y(offsetY) && offsetY !== null && closestMinY !== null && closestMidY !== null && closestMaxY !== null) {
+        if (isEqualNum(offsetY, closestMinY - targetBox.minY)) {
+            const hLine = {
+                y: closestMinY,
+                xList: []
+            };
+            hLine.xList.push(newTargetBox.minX);
+            hLine.xList.push(newTargetBox.maxX);
+            hLine.xList.push(...((vRefLineDotMap === null || vRefLineDotMap === void 0 ? void 0 : vRefLineDotMap[closestMinY]) || []));
+            hHelperLineDotMapList.push(hLine);
+        }
+        if (isEqualNum(offsetY, closestMidY - targetBox.midY)) {
+            const hLine = {
+                y: closestMidY,
+                xList: []
+            };
+            hLine.xList.push(newTargetBox.minX);
+            hLine.xList.push(newTargetBox.maxX);
+            hLine.xList.push(...((vRefLineDotMap === null || vRefLineDotMap === void 0 ? void 0 : vRefLineDotMap[closestMinY]) || []));
+            hHelperLineDotMapList.push(hLine);
+        }
+        if (isEqualNum(offsetY, closestMaxY - targetBox.maxY)) {
+            const hLine = {
+                y: closestMaxY,
+                xList: []
+            };
+            hLine.xList.push(newTargetBox.minX);
+            hLine.xList.push(newTargetBox.maxX);
+            hLine.xList.push(...((vRefLineDotMap === null || vRefLineDotMap === void 0 ? void 0 : vRefLineDotMap[closestMaxY]) || []));
+            hHelperLineDotMapList.push(hLine);
+        }
+    }
+    const yLines = [];
+    if ((vHelperLineDotMapList === null || vHelperLineDotMapList === void 0 ? void 0 : vHelperLineDotMapList.length) > 0) {
+        vHelperLineDotMapList.forEach((item, i) => {
+            yLines.push([]);
+            item.yList.forEach((y) => {
+                yLines[i].push({
+                    x: item.x,
+                    y
+                });
+            });
+        });
+    }
+    const xLines = [];
+    if ((hHelperLineDotMapList === null || hHelperLineDotMapList === void 0 ? void 0 : hHelperLineDotMapList.length) > 0) {
+        hHelperLineDotMapList.forEach((item, i) => {
+            xLines.push([]);
+            item.xList.forEach((x) => {
+                xLines[i].push({
+                    x,
+                    y: item.y
+                });
+            });
+        });
+    }
+    return {
+        offsetX,
+        offsetY,
+        yLines,
+        xLines
+    };
+}

package/dist/esm/middleware/selector/types.d.ts

@@ -1,14 +1,14 @@
-import type { ElementSizeController } from '@idraw/types';
-import { keyActionType, keyResizeType, keyAreaStart, keyAreaEnd, keyGroupQueue, keyGroupQueueVertexesList, keyHoverElement, keyHoverElementVertexes, keySelectedElementList, keySelectedElementListVertexes, keySelectedElementController, keyDebugElemCenter, keyDebugEnd0, keyDebugEndHorizontal, keyDebugEndVertical, keyDebugStartHorizontal, keyDebugStartVertical } from './config';
-import { Data, ElementSize, ElementType, Element, ViewContext2D, Point, PointSize, ViewScaleInfo, ViewSizeInfo, ViewCalculator, PointWatcherEvent, BoardMiddleware, ViewRectVertexes } from '@idraw/types';
-export { Data, ElementType, Element, ElementSize, ViewContext2D, Point, PointSize, ViewScaleInfo, ViewSizeInfo, ViewCalculator, PointWatcherEvent, BoardMiddleware };
+import { Data, ElementSize, ElementType, Element, ViewContext2D, Point, PointSize, ViewScaleInfo, ViewSizeInfo, ViewCalculator, PointWatcherEvent, Middleware, ViewRectVertexes, ElementSizeController, ElementPosition } from '@idraw/types';
+import { keyActionType, keyResizeType, keyAreaStart, keyAreaEnd, keyGroupQueue, keyGroupQueueVertexesList, keyHoverElement, keyHoverElementVertexes, keySelectedElementList, keySelectedElementListVertexes, keySelectedElementController, keySelectedElementPosition, keyIsMoving, keyEnableSelectInGroup, keyEnableSnapToGrid, keyDebugElemCenter, keyDebugEnd0, keyDebugEndHorizontal, keyDebugEndVertical, keyDebugStartHorizontal, keyDebugStartVertical } from './config';
+import { keyLayoutIsSelected, keyLayoutIsBusyMoving } from '../layout-selector';
+export { Data, ElementType, Element, ElementSize, ViewContext2D, Point, PointSize, ViewScaleInfo, ViewSizeInfo, ViewCalculator, PointWatcherEvent, Middleware };
 export type ControllerStyle = ElementSize & {
     borderWidth: number;
     borderColor: string;
     background: string;
 };
 export type SelectedElementSizeController = Record<string, ControllerStyle>;
-export type ResizeType = 'resize-left' | 'resize-right' | 'resize-top' | 'resize-bottom' | 'resize-top-left' | 'resize-top-right' | 'resize-bottom-left' | 'resize-bottom-right';
+export type ResizeType = 'resize-left' | 'resize-right' | 'resize-top' | 'resize-bottom' | 'resize-top-left' | 'resize-top-right' | 'resize-bottom-left' | 'resize-bottom-right' | 'resize-rotate';
 export type PointTargetType = null | ResizeType | 'list-area' | 'over-element';
 export interface PointTarget {
     type: PointTargetType;
@@ -31,10 +31,16 @@ export type DeepSelectorSharedStorage = {
     [keySelectedElementList]: Array<Element<ElementType>>;
     [keySelectedElementListVertexes]: ViewRectVertexes | null;
     [keySelectedElementController]: ElementSizeController | null;
+    [keySelectedElementPosition]: ElementPosition;
+    [keyIsMoving]: boolean | null;
+    [keyEnableSelectInGroup]: boolean | null;
+    [keyEnableSnapToGrid]: boolean | null;
     [keyDebugElemCenter]: PointSize | null;
     [keyDebugEnd0]: PointSize | null;
     [keyDebugEndHorizontal]: PointSize | null;
     [keyDebugEndVertical]: PointSize | null;
     [keyDebugStartHorizontal]: PointSize | null;
     [keyDebugStartVertical]: PointSize | null;
+    [keyLayoutIsSelected]: boolean | null;
+    [keyLayoutIsBusyMoving]: boolean | null;
 };

package/dist/esm/middleware/selector/types.js

@@ -1 +1,2 @@
-import { keyActionType, keyResizeType, keyAreaStart, keyAreaEnd, keyGroupQueue, keyGroupQueueVertexesList, keyHoverElement, keyHoverElementVertexes, keySelectedElementList, keySelectedElementListVertexes, keySelectedElementController, keyDebugElemCenter, keyDebugEnd0, keyDebugEndHorizontal, keyDebugEndVertical, keyDebugStartHorizontal, keyDebugStartVertical } from './config';
+import { keyActionType, keyResizeType, keyAreaStart, keyAreaEnd, keyGroupQueue, keyGroupQueueVertexesList, keyHoverElement, keyHoverElementVertexes, keySelectedElementList, keySelectedElementListVertexes, keySelectedElementController, keySelectedElementPosition, keyIsMoving, keyEnableSelectInGroup, keyEnableSnapToGrid, keyDebugElemCenter, keyDebugEnd0, keyDebugEndHorizontal, keyDebugEndVertical, keyDebugStartHorizontal, keyDebugStartVertical } from './config';
+import { keyLayoutIsSelected, keyLayoutIsBusyMoving } from '../layout-selector';

package/dist/esm/middleware/selector/util.d.ts

@@ -1,5 +1,5 @@
-import type { ViewRectVertexes, ElementSizeController, StoreSharer } from '@idraw/types';
-import type { Data, Element, ViewContext2D, Point, PointSize, PointTarget, ViewScaleInfo, ViewCalculator, ElementType, ElementSize, ResizeType, AreaSize, ViewSizeInfo } from './types';
+import type { ViewRectVertexes, ElementSizeController, StoreSharer, ViewScaleInfo, ViewSizeInfo, ElementOperations } from '@idraw/types';
+import type { Data, Element, ViewContext2D, Point, PointSize, PointTarget, ViewCalculator, ElementType, ElementSize, ResizeType, AreaSize } from './types';
 export declare function isPointInViewActiveVertexes(p: PointSize, opts: {
     ctx: ViewContext2D;
     vertexes: ViewRectVertexes;
@@ -23,13 +23,24 @@ export declare function getPointTarget(p: PointSize, opts: {
     groupQueue: Element<'group'>[] | null;
     selectedElementController: ElementSizeController | null;
 }): PointTarget;
-export declare function resizeElement(elem: Element<ElementType>, opts: {
+export declare function resizeElement(elem: ElementSize & {
+    operations?: ElementOperations;
+}, opts: {
     start: PointSize;
     end: PointSize;
     resizeType: ResizeType;
     scale: number;
     sharer: StoreSharer;
 }): ElementSize;
+export declare function rotateElement(elem: ElementSize, opts: {
+    center: PointSize;
+    start: PointSize;
+    end: PointSize;
+    resizeType: ResizeType;
+    viewScaleInfo: ViewScaleInfo;
+    viewSizeInfo: ViewSizeInfo;
+    sharer: StoreSharer;
+}): ElementSize;
 export declare function getSelectedListArea(data: Data, opts: {
     start: Point;
     end: Point;
@@ -47,7 +58,3 @@ export declare function calcSelectedElementsArea(elements: Element<ElementType>[
     calculator: ViewCalculator;
 }): AreaSize | null;
 export declare function isElementInGroup(elem: Element<ElementType>, group: Element<'group'>): boolean;
-export declare function calcMoveInGroup(start: PointSize, end: PointSize, groupQueue: Element<'group'>[]): {
-    moveX: number;
-    moveY: number;
-};