@idraw/core 0.3.1 → 0.4.0-alpha.2

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

@@ -0,0 +1,454 @@
+import { calcElementsViewInfo, calcElementVertexesInGroup, calcElementQueueVertexesQueueInGroup, calcElementSizeController, rotatePointInGroup, getGroupQueueFromList, findElementsFromList } from '@idraw/util';
+import { drawHoverVertexesWrapper, drawArea, drawListArea, drawGroupQueueVertexesWrappers, drawSelectedElementControllersVertexes } from './draw-wrapper';
+import { getPointTarget, resizeElement, getSelectedListArea, calcSelectedElementsArea, isElementInGroup, isPointInViewActiveGroup, calcMoveInGroup } from './util';
+import { key, keyActionType, keyResizeType, keyAreaStart, keyAreaEnd, keyGroupQueue, keyGroupQueueVertexesList, keyHoverElement, keyHoverElementVertexes, keySelectedElementList, keySelectedElementListVertexes, keySelectedElementController } from './config';
+export const MiddlewareSelector = (opts) => {
+    const { viewer, sharer, viewContent, calculator, eventHub } = opts;
+    const { helperContext } = viewContent;
+    let prevPoint = null;
+    let inBusyMode = null;
+    eventHub.on('select', ({ uuids }) => {
+        const actionType = sharer.getSharedStorage(keyActionType);
+        const data = sharer.getActiveStorage('data');
+        const elements = findElementsFromList(uuids, (data === null || data === void 0 ? void 0 : data.elements) || []);
+        let needRefresh = false;
+        if (!actionType && elements.length === 1) {
+            sharer.setSharedStorage(keyActionType, 'select');
+            needRefresh = true;
+        }
+        else if (actionType === 'select' && elements.length === 1) {
+            needRefresh = true;
+        }
+        if (needRefresh) {
+            const elem = elements[0];
+            const groupQueue = getGroupQueueFromList(elem.uuid, (data === null || data === void 0 ? void 0 : data.elements) || []);
+            sharer.setSharedStorage(keyGroupQueue, groupQueue);
+            updateSelectedElementList(elements);
+            viewer.drawFrame();
+        }
+    });
+    sharer.setSharedStorage(keyActionType, null);
+    const getActiveElements = () => {
+        return sharer.getSharedStorage(keySelectedElementList);
+    };
+    const pushGroupQueue = (elem) => {
+        let groupQueue = sharer.getSharedStorage(keyGroupQueue);
+        if (!Array.isArray(groupQueue)) {
+            groupQueue = [];
+        }
+        if (groupQueue.length > 0) {
+            if (isElementInGroup(elem, groupQueue[groupQueue.length - 1])) {
+                groupQueue.push(elem);
+            }
+            else {
+                groupQueue = [];
+            }
+        }
+        else if (groupQueue.length === 0) {
+            groupQueue.push(elem);
+        }
+        const vertexesList = calcElementQueueVertexesQueueInGroup(groupQueue);
+        sharer.setSharedStorage(keyGroupQueue, groupQueue);
+        sharer.setSharedStorage(keyGroupQueueVertexesList, vertexesList);
+        return groupQueue.length > 0;
+    };
+    const updateHoverElement = (elem) => {
+        sharer.setSharedStorage(keyHoverElement, elem);
+        let vertexes = null;
+        if (elem) {
+            vertexes = calcElementVertexesInGroup(elem, {
+                groupQueue: sharer.getSharedStorage(keyGroupQueue)
+            });
+        }
+        sharer.setSharedStorage(keyHoverElementVertexes, vertexes);
+    };
+    const updateSelectedElementList = (list, opts) => {
+        sharer.setSharedStorage(keySelectedElementList, list);
+        if (list.length === 1) {
+            const controller = calcElementSizeController(list[0], {
+                groupQueue: sharer.getSharedStorage(keyGroupQueue),
+                controllerSize: 10,
+                viewScaleInfo: sharer.getActiveViewScaleInfo()
+            });
+            sharer.setSharedStorage(keySelectedElementController, controller);
+        }
+        else {
+            sharer.setSharedStorage(keySelectedElementController, null);
+        }
+        if ((opts === null || opts === void 0 ? void 0 : opts.triggerEvent) === true) {
+            eventHub.trigger('select', { uuids: list.map((elem) => elem.uuid) });
+        }
+    };
+    const pointTargetBaseOptions = () => {
+        return {
+            ctx: helperContext,
+            calculator,
+            data: sharer.getActiveStorage('data'),
+            selectedElements: getActiveElements(),
+            viewScaleInfo: sharer.getActiveViewScaleInfo(),
+            viewSizeInfo: sharer.getActiveViewSizeInfo(),
+            groupQueue: sharer.getSharedStorage(keyGroupQueue),
+            areaSize: null,
+            selectedElementController: sharer.getSharedStorage(keySelectedElementController)
+        };
+    };
+    const clear = () => {
+        sharer.setSharedStorage(keyActionType, null);
+        sharer.setSharedStorage(keyResizeType, null);
+        sharer.setSharedStorage(keyAreaStart, null);
+        sharer.setSharedStorage(keyAreaEnd, null);
+        sharer.setSharedStorage(keyGroupQueue, []);
+        sharer.setSharedStorage(keyGroupQueueVertexesList, []);
+        sharer.setSharedStorage(keyHoverElement, null);
+        sharer.setSharedStorage(keyHoverElementVertexes, null);
+        sharer.setSharedStorage(keySelectedElementList, []);
+        sharer.setSharedStorage(keySelectedElementListVertexes, null);
+        sharer.setSharedStorage(keySelectedElementController, null);
+    };
+    clear();
+    return {
+        mode: key,
+        hover: (e) => {
+            var _a, _b;
+            const resizeType = sharer.getSharedStorage(keyResizeType);
+            const actionType = sharer.getSharedStorage(keyActionType);
+            const groupQueue = sharer.getSharedStorage(keyGroupQueue);
+            const triggerCursor = (target) => {
+                let cursor = target.type;
+                if (inBusyMode === null) {
+                    eventHub.trigger('cursor', {
+                        type: cursor,
+                        groupQueue: target.groupQueue,
+                        element: target.elements[0]
+                    });
+                }
+            };
+            if ((groupQueue === null || groupQueue === void 0 ? void 0 : groupQueue.length) > 0) {
+                const isInActiveGroup = isPointInViewActiveGroup(e.point, {
+                    ctx: helperContext,
+                    viewScaleInfo: sharer.getActiveViewScaleInfo(),
+                    viewSizeInfo: sharer.getActiveViewSizeInfo(),
+                    groupQueue: sharer.getSharedStorage(keyGroupQueue)
+                });
+                if (!isInActiveGroup) {
+                    updateHoverElement(null);
+                    viewer.drawFrame();
+                    return;
+                }
+                const target = getPointTarget(e.point, pointTargetBaseOptions());
+                triggerCursor(target);
+                if (resizeType || ['area', 'drag', 'drag-list'].includes(actionType)) {
+                    updateHoverElement(null);
+                    viewer.drawFrame();
+                    return;
+                }
+                if (((_a = target === null || target === void 0 ? void 0 : target.elements) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+                    updateHoverElement(target.elements[0]);
+                    viewer.drawFrame();
+                    return;
+                }
+                updateHoverElement(null);
+                viewer.drawFrame();
+                return;
+            }
+            if (resizeType || ['area', 'drag', 'drag-list'].includes(actionType)) {
+                updateHoverElement(null);
+                return;
+            }
+            if (actionType === 'drag') {
+                updateHoverElement(null);
+                return;
+            }
+            const selectedElements = getActiveElements();
+            const viewScaleInfo = sharer.getActiveViewScaleInfo();
+            const viewSizeInfo = sharer.getActiveViewSizeInfo();
+            const target = getPointTarget(e.point, Object.assign(Object.assign({}, pointTargetBaseOptions()), { areaSize: calcSelectedElementsArea(selectedElements, {
+                    viewScaleInfo,
+                    viewSizeInfo,
+                    calculator
+                }) }));
+            triggerCursor(target);
+            if (target.type === 'over-element' && ((_b = target === null || target === void 0 ? void 0 : target.elements) === null || _b === void 0 ? void 0 : _b.length) === 1) {
+                sharer.setSharedStorage(keyHoverElement, target.elements[0]);
+                updateHoverElement(target.elements[0]);
+                viewer.drawFrame();
+                return;
+            }
+            if (sharer.getSharedStorage(keyHoverElement)) {
+                updateHoverElement(null);
+                viewer.drawFrame();
+                return;
+            }
+        },
+        pointStart: (e) => {
+            var _a, _b, _c, _d;
+            prevPoint = e.point;
+            updateHoverElement(null);
+            const groupQueue = sharer.getSharedStorage(keyGroupQueue);
+            if ((groupQueue === null || groupQueue === void 0 ? void 0 : groupQueue.length) > 0) {
+                if (isPointInViewActiveGroup(e.point, {
+                    ctx: helperContext,
+                    viewScaleInfo: sharer.getActiveViewScaleInfo(),
+                    viewSizeInfo: sharer.getActiveViewSizeInfo(),
+                    groupQueue
+                })) {
+                    const target = getPointTarget(e.point, pointTargetBaseOptions());
+                    updateHoverElement(null);
+                    if (target.type === 'over-element' && ((_a = target === null || target === void 0 ? void 0 : target.elements) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+                        updateSelectedElementList([target.elements[0]], { triggerEvent: true });
+                        sharer.setSharedStorage(keyActionType, 'drag');
+                    }
+                    else if ((_b = target.type) === null || _b === void 0 ? void 0 : _b.startsWith('resize-')) {
+                        sharer.setSharedStorage(keyResizeType, target.type);
+                        sharer.setSharedStorage(keyActionType, 'resize');
+                    }
+                    else {
+                        updateSelectedElementList([], { triggerEvent: true });
+                    }
+                }
+                else {
+                    clear();
+                }
+                viewer.drawFrame();
+                return;
+            }
+            const listAreaSize = calcSelectedElementsArea(getActiveElements(), {
+                viewScaleInfo: sharer.getActiveViewScaleInfo(),
+                viewSizeInfo: sharer.getActiveViewSizeInfo(),
+                calculator
+            });
+            const target = getPointTarget(e.point, Object.assign(Object.assign({}, pointTargetBaseOptions()), { areaSize: listAreaSize, groupQueue: [] }));
+            if (target.type === 'list-area') {
+                sharer.setSharedStorage(keyActionType, 'drag-list');
+            }
+            else if (target.type === 'over-element' && ((_c = target === null || target === void 0 ? void 0 : target.elements) === null || _c === void 0 ? void 0 : _c.length) === 1) {
+                updateSelectedElementList([target.elements[0]], { triggerEvent: true });
+                sharer.setSharedStorage(keyActionType, 'drag');
+            }
+            else if ((_d = target.type) === null || _d === void 0 ? void 0 : _d.startsWith('resize-')) {
+                sharer.setSharedStorage(keyResizeType, target.type);
+                sharer.setSharedStorage(keyActionType, 'resize');
+            }
+            else {
+                clear();
+                sharer.setSharedStorage(keyActionType, 'area');
+                sharer.setSharedStorage(keyAreaStart, e.point);
+                updateSelectedElementList([], { triggerEvent: true });
+            }
+            viewer.drawFrame();
+        },
+        pointMove: (e) => {
+            const data = sharer.getActiveStorage('data');
+            const elems = getActiveElements();
+            const scale = sharer.getActiveStorage('scale') || 1;
+            const start = prevPoint;
+            const end = e.point;
+            const resizeType = sharer.getSharedStorage(keyResizeType);
+            const actionType = sharer.getSharedStorage(keyActionType);
+            const groupQueue = sharer.getSharedStorage(keyGroupQueue);
+            if (actionType === 'drag') {
+                inBusyMode = 'drag';
+                if (data && (elems === null || elems === void 0 ? void 0 : elems.length) === 1 && start && end) {
+                    const { moveX, moveY } = calcMoveInGroup(start, end, groupQueue);
+                    elems[0].x += moveX / scale;
+                    elems[0].y += moveY / scale;
+                    updateSelectedElementList([elems[0]]);
+                }
+                viewer.drawFrame();
+            }
+            else if (actionType === 'drag-list') {
+                inBusyMode = 'drag-list';
+                if (data && start && end && (elems === null || elems === void 0 ? void 0 : elems.length) > 1) {
+                    const moveX = (end.x - start.x) / scale;
+                    const moveY = (end.y - start.y) / scale;
+                    elems.forEach((elem) => {
+                        if (elem) {
+                            elem.x += moveX;
+                            elem.y += moveY;
+                        }
+                    });
+                    sharer.setActiveStorage('data', data);
+                }
+                viewer.drawFrame();
+            }
+            else if (actionType === 'resize') {
+                if (data && (elems === null || elems === void 0 ? void 0 : elems.length) === 1 && start && (resizeType === null || resizeType === void 0 ? void 0 : resizeType.startsWith('resize-'))) {
+                    inBusyMode = 'resize';
+                    const pointGroupQueue = [];
+                    groupQueue.forEach((group) => {
+                        const { x, y, w, h, angle = 0 } = group;
+                        pointGroupQueue.push({
+                            x,
+                            y,
+                            w,
+                            h,
+                            angle: 0 - angle
+                        });
+                    });
+                    let resizeStart = start;
+                    let resizeEnd = end;
+                    if (groupQueue.length > 0) {
+                        resizeStart = rotatePointInGroup(start, pointGroupQueue);
+                        resizeEnd = rotatePointInGroup(end, pointGroupQueue);
+                    }
+                    const resizedElemSize = resizeElement(elems[0], { scale, start: resizeStart, end: resizeEnd, resizeType, sharer });
+                    elems[0].x = resizedElemSize.x;
+                    elems[0].y = resizedElemSize.y;
+                    elems[0].w = resizedElemSize.w;
+                    elems[0].h = resizedElemSize.h;
+                    updateSelectedElementList([elems[0]]);
+                    viewer.drawFrame();
+                }
+            }
+            else if (actionType === 'area') {
+                inBusyMode = 'area';
+                sharer.setSharedStorage(keyAreaEnd, e.point);
+                viewer.drawFrame();
+            }
+            prevPoint = e.point;
+        },
+        pointEnd(e) {
+            inBusyMode = null;
+            const data = sharer.getActiveStorage('data');
+            const resizeType = sharer.getSharedStorage(keyResizeType);
+            const actionType = sharer.getSharedStorage(keyActionType);
+            const viewSizeInfo = sharer.getActiveViewSizeInfo();
+            let needDrawFrame = false;
+            prevPoint = null;
+            if (actionType === 'resize' && resizeType) {
+                sharer.setSharedStorage(keyResizeType, null);
+                needDrawFrame = true;
+            }
+            else if (actionType === 'area') {
+                sharer.setSharedStorage(keyActionType, null);
+                if (data) {
+                    const start = sharer.getSharedStorage(keyAreaStart);
+                    const end = sharer.getSharedStorage(keyAreaEnd);
+                    if (start && end) {
+                        const { elements } = getSelectedListArea(data, {
+                            start,
+                            end,
+                            calculator,
+                            viewScaleInfo: sharer.getActiveViewScaleInfo(),
+                            viewSizeInfo: sharer.getActiveViewSizeInfo()
+                        });
+                        if (elements.length > 0) {
+                            sharer.setSharedStorage(keyActionType, 'drag-list');
+                            updateSelectedElementList(elements, { triggerEvent: true });
+                            needDrawFrame = true;
+                        }
+                    }
+                }
+            }
+            else if (actionType === 'drag-list') {
+                sharer.setSharedStorage(keyActionType, 'drag-list-end');
+                needDrawFrame = true;
+            }
+            else if (data) {
+                const result = calculator.getPointElement(e.point, {
+                    data,
+                    viewScaleInfo: sharer.getActiveViewScaleInfo(),
+                    viewSizeInfo: sharer.getActiveViewSizeInfo()
+                });
+                if (result.element) {
+                    sharer.setSharedStorage(keyActionType, 'select');
+                    needDrawFrame = true;
+                }
+                else {
+                    sharer.setSharedStorage(keyActionType, null);
+                }
+            }
+            if (sharer.getSharedStorage(keyActionType) === null) {
+                clear();
+                needDrawFrame = true;
+            }
+            const finalDrawFrame = () => {
+                if (!needDrawFrame) {
+                    return;
+                }
+                if (data && Array.isArray(data === null || data === void 0 ? void 0 : data.elements) && ['drag', 'drag-list'].includes(actionType)) {
+                    const viewInfo = calcElementsViewInfo(data.elements, viewSizeInfo, { extend: true });
+                    sharer.setActiveStorage('contextHeight', viewInfo.contextSize.contextHeight);
+                    sharer.setActiveStorage('contextWidth', viewInfo.contextSize.contextWidth);
+                }
+                if (data && ['drag', 'drag-list', 'drag-list-end', 'resize'].includes(actionType)) {
+                    eventHub.trigger('change', { data });
+                }
+                viewer.drawFrame();
+            };
+            finalDrawFrame();
+        },
+        pointLeave() {
+            prevPoint = null;
+            clear();
+            viewer.drawFrame();
+        },
+        doubleClick(e) {
+            var _a;
+            const target = getPointTarget(e.point, pointTargetBaseOptions());
+            if (target.elements.length === 1 && ((_a = target.elements[0]) === null || _a === void 0 ? void 0 : _a.type) === 'group') {
+                const pushResult = pushGroupQueue(target.elements[0]);
+                if (pushResult === true) {
+                    sharer.setSharedStorage(keyActionType, null);
+                    viewer.drawFrame();
+                    return;
+                }
+            }
+            sharer.setSharedStorage(keyActionType, null);
+        },
+        beforeDrawFrame({ snapshot }) {
+            const { activeStore, sharedStore } = snapshot;
+            const { scale, offsetLeft, offsetTop, offsetRight, offsetBottom, width, height, contextHeight, contextWidth, devicePixelRatio } = activeStore;
+            const sharer = opts.sharer;
+            const viewScaleInfo = { scale, offsetLeft, offsetTop, offsetRight, offsetBottom };
+            const viewSizeInfo = { width, height, contextHeight, contextWidth, devicePixelRatio };
+            const selectedElements = sharedStore[keySelectedElementList];
+            const elem = selectedElements[0];
+            const hoverElement = sharedStore[keyHoverElement];
+            const hoverElementVertexes = sharedStore[keyHoverElementVertexes];
+            const actionType = sharedStore[keyActionType];
+            const areaStart = sharedStore[keyAreaStart];
+            const areaEnd = sharedStore[keyAreaEnd];
+            const groupQueue = sharedStore[keyGroupQueue];
+            const groupQueueVertexesList = sharedStore[keyGroupQueueVertexesList];
+            const drawBaseOpts = { calculator, viewScaleInfo, viewSizeInfo };
+            const selectedElementController = elem
+                ? calcElementSizeController(elem, {
+                    groupQueue,
+                    controllerSize: 10,
+                    viewScaleInfo
+                })
+                : null;
+            if ((groupQueue === null || groupQueue === void 0 ? void 0 : groupQueue.length) > 0) {
+                drawGroupQueueVertexesWrappers(helperContext, groupQueueVertexesList, drawBaseOpts);
+                if (hoverElement && actionType !== 'drag') {
+                    drawHoverVertexesWrapper(helperContext, hoverElementVertexes, drawBaseOpts);
+                }
+                if (elem && ['select', 'drag', 'resize'].includes(actionType)) {
+                    drawSelectedElementControllersVertexes(helperContext, selectedElementController, Object.assign({}, drawBaseOpts));
+                }
+            }
+            else {
+                if (hoverElement && actionType !== 'drag') {
+                    drawHoverVertexesWrapper(helperContext, hoverElementVertexes, drawBaseOpts);
+                }
+                if (elem && ['select', 'drag', 'resize'].includes(actionType)) {
+                    drawSelectedElementControllersVertexes(helperContext, selectedElementController, Object.assign({}, drawBaseOpts));
+                }
+                else if (actionType === 'area' && areaStart && areaEnd) {
+                    drawArea(helperContext, { start: areaStart, end: areaEnd });
+                }
+                else if (['drag-list', 'drag-list-end'].includes(actionType)) {
+                    const listAreaSize = calcSelectedElementsArea(getActiveElements(), {
+                        viewScaleInfo: sharer.getActiveViewScaleInfo(),
+                        viewSizeInfo: sharer.getActiveViewSizeInfo(),
+                        calculator
+                    });
+                    if (listAreaSize) {
+                        drawListArea(helperContext, { areaSize: listAreaSize });
+                    }
+                }
+            }
+        }
+    };
+};

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

@@ -0,0 +1,40 @@
+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 };
+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 PointTargetType = null | ResizeType | 'list-area' | 'over-element';
+export interface PointTarget {
+    type: PointTargetType;
+    elements: Element<ElementType>[];
+    groupQueue: Element<'group'>[];
+    elementVertexesList: ViewRectVertexes[];
+    groupQueueVertexesList: ViewRectVertexes[];
+}
+export type AreaSize = ElementSize;
+export type ActionType = 'select' | 'drag-list' | 'drag-list-end' | 'drag' | 'hover' | 'resize' | 'area' | null;
+export type DeepSelectorSharedStorage = {
+    [keyActionType]: ActionType | null;
+    [keyResizeType]: ResizeType | null;
+    [keyAreaStart]: Point | null;
+    [keyAreaEnd]: Point | null;
+    [keyGroupQueue]: Element<'group'>[];
+    [keyGroupQueueVertexesList]: ViewRectVertexes[];
+    [keyHoverElement]: Element<ElementType> | null;
+    [keyHoverElementVertexes]: ViewRectVertexes | null;
+    [keySelectedElementList]: Array<Element<ElementType>>;
+    [keySelectedElementListVertexes]: ViewRectVertexes | null;
+    [keySelectedElementController]: ElementSizeController | null;
+    [keyDebugElemCenter]: PointSize | null;
+    [keyDebugEnd0]: PointSize | null;
+    [keyDebugEndHorizontal]: PointSize | null;
+    [keyDebugEndVertical]: PointSize | null;
+    [keyDebugStartHorizontal]: PointSize | null;
+    [keyDebugStartVertical]: PointSize | null;
+};

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

@@ -0,0 +1 @@
+import { keyActionType, keyResizeType, keyAreaStart, keyAreaEnd, keyGroupQueue, keyGroupQueueVertexesList, keyHoverElement, keyHoverElementVertexes, keySelectedElementList, keySelectedElementListVertexes, keySelectedElementController, keyDebugElemCenter, keyDebugEnd0, keyDebugEndHorizontal, keyDebugEndVertical, keyDebugStartHorizontal, keyDebugStartVertical } from './config';

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

@@ -0,0 +1,53 @@
+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';
+export declare function isPointInViewActiveVertexes(p: PointSize, opts: {
+    ctx: ViewContext2D;
+    vertexes: ViewRectVertexes;
+    viewScaleInfo: ViewScaleInfo;
+    viewSizeInfo: ViewSizeInfo;
+}): boolean;
+export declare function isPointInViewActiveGroup(p: PointSize, opts: {
+    ctx: ViewContext2D;
+    viewScaleInfo: ViewScaleInfo;
+    viewSizeInfo: ViewSizeInfo;
+    groupQueue: Element<'group'>[] | null;
+}): boolean;
+export declare function getPointTarget(p: PointSize, opts: {
+    ctx: ViewContext2D;
+    data?: Data | null;
+    selectedElements?: Element<ElementType>[];
+    areaSize?: AreaSize | null;
+    viewScaleInfo: ViewScaleInfo;
+    viewSizeInfo: ViewSizeInfo;
+    calculator: ViewCalculator;
+    groupQueue: Element<'group'>[] | null;
+    selectedElementController: ElementSizeController | null;
+}): PointTarget;
+export declare function resizeElement(elem: Element<ElementType>, opts: {
+    start: PointSize;
+    end: PointSize;
+    resizeType: ResizeType;
+    scale: number;
+    sharer: StoreSharer;
+}): ElementSize;
+export declare function getSelectedListArea(data: Data, opts: {
+    start: Point;
+    end: Point;
+    viewScaleInfo: ViewScaleInfo;
+    viewSizeInfo: ViewSizeInfo;
+    calculator: ViewCalculator;
+}): {
+    indexes: number[];
+    uuids: string[];
+    elements: Element<ElementType>[];
+};
+export declare function calcSelectedElementsArea(elements: Element<ElementType>[], opts: {
+    viewScaleInfo: ViewScaleInfo;
+    viewSizeInfo: ViewSizeInfo;
+    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;
+};