@idraw/util 0.4.0-beta.34 → 0.4.0-beta.36

package/dist/esm/index.d.ts

@@ -14,7 +14,7 @@ export { Store } from './lib/store';
 export { getViewScaleInfoFromSnapshot, getViewSizeInfoFromSnapshot } from './lib/middleware';
 export { Context2D } from './lib/context2d';
 export { rotateElement, parseRadianToAngle, parseAngleToRadian, rotateElementVertexes, getElementRotateVertexes, calcElementCenter, calcElementCenterFromVertexes, rotatePointInGroup, limitAngle, calcRadian } from './lib/rotate';
-export { getSelectedElementUUIDs, validateElements, calcElementsContextSize, calcElementsViewInfo, getElemenetsAssetIds, findElementFromList, findElementsFromList, findElementFromListByPosition, findElementQueueFromListByPosition, findElementsFromListByPositions, getGroupQueueFromList, getGroupQueueByElementPosition, getElementSize, mergeElementAsset, filterElementAsset, isResourceElement, getElementPositionFromList, calcElementListSize } from './lib/element';
+export { getSelectedElementUUIDs, validateElements, calcElementsContextSize, calcElementsViewInfo, getElemenetsAssetIds, findElementFromList, findElementsFromList, findElementFromListByPosition, findElementQueueFromListByPosition, findElementsFromListByPositions, getGroupQueueFromList, getGroupQueueByElementPosition, getElementSize, mergeElementAsset, filterElementAsset, isResourceElement, getElementPositionFromList, getElementPositionMapFromList, calcElementListSize } from './lib/element';
 export { checkRectIntersect } from './lib/rect';
 export { viewScale, viewScroll, calcViewElementSize, calcViewPointSize, calcViewVertexes, isViewPointInElement, getViewPointAtElement, isElementInView, calcViewScaleInfo, calcElementViewRectInfo, calcElementOriginRectInfo, calcElementViewRectInfoMap, originRectInfoToRangeRectInfo, isViewPointInElementSize, isViewPointInVertexes } from './lib/view-calc';
 export { sortElementsViewVisiableInfoMap, calcVisibleOriginCanvasRectInfo, updateViewVisibleInfoMapStatus } from './lib/view-visible';
@@ -34,3 +34,4 @@ export { calcViewCenterContent, calcViewCenter } from './lib/view-content';
 export { modifyElement, getModifiedElement } from './lib/modify';
 export { enhanceFontFamliy } from './lib/text';
 export { flatElementList } from './lib/flat';
+export { groupElementsByPosition, ungroupElementsByPosition } from './lib/group';

package/dist/esm/index.js

@@ -14,7 +14,7 @@ export { Store } from './lib/store';
 export { getViewScaleInfoFromSnapshot, getViewSizeInfoFromSnapshot } from './lib/middleware';
 export { Context2D } from './lib/context2d';
 export { rotateElement, parseRadianToAngle, parseAngleToRadian, rotateElementVertexes, getElementRotateVertexes, calcElementCenter, calcElementCenterFromVertexes, rotatePointInGroup, limitAngle, calcRadian } from './lib/rotate';
-export { getSelectedElementUUIDs, validateElements, calcElementsContextSize, calcElementsViewInfo, getElemenetsAssetIds, findElementFromList, findElementsFromList, findElementFromListByPosition, findElementQueueFromListByPosition, findElementsFromListByPositions, getGroupQueueFromList, getGroupQueueByElementPosition, getElementSize, mergeElementAsset, filterElementAsset, isResourceElement, getElementPositionFromList, calcElementListSize } from './lib/element';
+export { getSelectedElementUUIDs, validateElements, calcElementsContextSize, calcElementsViewInfo, getElemenetsAssetIds, findElementFromList, findElementsFromList, findElementFromListByPosition, findElementQueueFromListByPosition, findElementsFromListByPositions, getGroupQueueFromList, getGroupQueueByElementPosition, getElementSize, mergeElementAsset, filterElementAsset, isResourceElement, getElementPositionFromList, getElementPositionMapFromList, calcElementListSize } from './lib/element';
 export { checkRectIntersect } from './lib/rect';
 export { viewScale, viewScroll, calcViewElementSize, calcViewPointSize, calcViewVertexes, isViewPointInElement, getViewPointAtElement, isElementInView, calcViewScaleInfo, calcElementViewRectInfo, calcElementOriginRectInfo, calcElementViewRectInfoMap, originRectInfoToRangeRectInfo, isViewPointInElementSize, isViewPointInVertexes } from './lib/view-calc';
 export { sortElementsViewVisiableInfoMap, calcVisibleOriginCanvasRectInfo, updateViewVisibleInfoMapStatus } from './lib/view-visible';
@@ -34,3 +34,4 @@ export { calcViewCenterContent, calcViewCenter } from './lib/view-content';
 export { modifyElement, getModifiedElement } from './lib/modify';
 export { enhanceFontFamliy } from './lib/text';
 export { flatElementList } from './lib/flat';
+export { groupElementsByPosition, ungroupElementsByPosition } from './lib/group';

package/dist/esm/lib/controller.d.ts

@@ -1,7 +1,9 @@
 import type { Element, ElementSize, ElementSizeController, ViewScaleInfo, LayoutSizeController } from '@idraw/types';
 export declare function calcElementSizeController(elemSize: ElementSize, opts: {
     groupQueue: Element<'group'>[];
-    controllerSize?: number;
+    controllerSize: number;
+    rotateControllerSize: number;
+    rotateControllerPosition: number;
     viewScaleInfo: ViewScaleInfo;
 }): ElementSizeController;
 export declare function calcLayoutSizeController(layoutSize: Pick<ElementSize, 'x' | 'y' | 'w' | 'h'>, opts: {

package/dist/esm/lib/controller.js

@@ -15,9 +15,11 @@ function createControllerElementSizeFromCenter(center, opts) {
     };
 }
 export function calcElementSizeController(elemSize, opts) {
-    const { groupQueue, controllerSize, viewScaleInfo } = opts;
+    const { groupQueue, controllerSize, viewScaleInfo, rotateControllerSize, rotateControllerPosition } = opts;
     const ctrlSize = (controllerSize && controllerSize > 0 ? controllerSize : 8) / viewScaleInfo.scale;
     const { x, y, w, h, angle = 0 } = elemSize;
+    const rotateCtrlSize = rotateControllerSize;
+    const rotateCtrlPos = rotateControllerPosition;
     const ctrlGroupQueue = [
         ...[
             {
@@ -39,10 +41,10 @@ export function calcElementSizeController(elemSize, opts) {
     });
     const vertexes = calcElementVertexesInGroup(elemSize, { groupQueue });
     const rotateElemVertexes = calcElementVertexesInGroup({
-        x: x - ctrlSize * 2,
-        y: y - ctrlSize * 2,
-        h: h + ctrlSize * 4,
-        w: w + ctrlSize * 4,
+        x: x,
+        y: y - (rotateCtrlPos + rotateCtrlSize / 2) / viewScaleInfo.scale,
+        h: h + (rotateCtrlPos * 2 + rotateCtrlSize) / viewScaleInfo.scale,
+        w: w,
         angle
     }, { groupQueue: [...groupQueue] });
     const topCenter = getCenterFromTwoPoints(vertexes[0], vertexes[1]);
@@ -74,74 +76,91 @@ export function calcElementSizeController(elemSize, opts) {
     const bottomMiddleVertexes = calcElementVertexes(bottomMiddleSize);
     const leftMiddleVertexes = calcElementVertexes(leftMiddleSize);
     const rotateCenter = getCenterFromTwoPoints(rotateElemVertexes[0], rotateElemVertexes[1]);
-    const rotateSize = createControllerElementSizeFromCenter(rotateCenter, { size: ctrlSize, angle: totalAngle });
+    const tempRotateSizeRepairRatio = 1.1;
+    const rotateSize = createControllerElementSizeFromCenter(rotateCenter, {
+        size: (rotateControllerSize * tempRotateSizeRepairRatio) / viewScaleInfo.scale,
+        angle: totalAngle
+    });
     const rotateVertexes = calcElementVertexes(rotateSize);
     const sizeController = {
         elementWrapper: vertexes,
         left: {
             type: 'left',
             vertexes: leftVertexes,
-            center: leftCenter
+            center: leftCenter,
+            size: ctrlSize
         },
         right: {
             type: 'right',
             vertexes: rightVertexes,
-            center: rightCenter
+            center: rightCenter,
+            size: ctrlSize
         },
         top: {
             type: 'top',
             vertexes: topVertexes,
-            center: topCenter
+            center: topCenter,
+            size: ctrlSize
         },
         bottom: {
             type: 'bottom',
             vertexes: bottomVertexes,
-            center: bottomCenter
+            center: bottomCenter,
+            size: ctrlSize
         },
         topLeft: {
             type: 'top-left',
             vertexes: topLeftVertexes,
-            center: topLeftCenter
+            center: topLeftCenter,
+            size: ctrlSize
         },
         topRight: {
             type: 'top-right',
             vertexes: topRightVertexes,
-            center: topRightCenter
+            center: topRightCenter,
+            size: ctrlSize
         },
         bottomLeft: {
             type: 'bottom-left',
             vertexes: bottomLeftVertexes,
-            center: bottomLeftCenter
+            center: bottomLeftCenter,
+            size: ctrlSize
         },
         bottomRight: {
             type: 'bottom-right',
             vertexes: bottomRightVertexes,
-            center: bottomRightCenter
+            center: bottomRightCenter,
+            size: ctrlSize
         },
         leftMiddle: {
             type: 'left-middle',
             vertexes: leftMiddleVertexes,
-            center: leftCenter
+            center: leftCenter,
+            size: ctrlSize
         },
         rightMiddle: {
             type: 'right-middle',
             vertexes: rightMiddleVertexes,
-            center: rightCenter
+            center: rightCenter,
+            size: ctrlSize
         },
         topMiddle: {
             type: 'top-middle',
             vertexes: topMiddleVertexes,
-            center: topCenter
+            center: topCenter,
+            size: ctrlSize
         },
         bottomMiddle: {
             type: 'bottom-middle',
             vertexes: bottomMiddleVertexes,
-            center: bottomCenter
+            center: bottomCenter,
+            size: ctrlSize
         },
         rotate: {
             type: 'rotate',
             vertexes: rotateVertexes,
-            center: rotateCenter
+            center: rotateCenter,
+            size: rotateControllerSize
         }
     };
     return sizeController;
@@ -183,62 +202,74 @@ export function calcLayoutSizeController(layoutSize, opts) {
         left: {
             type: 'left',
             vertexes: leftVertexes,
-            center: leftCenter
+            center: leftCenter,
+            size: ctrlSize
         },
         right: {
             type: 'right',
             vertexes: rightVertexes,
-            center: rightCenter
+            center: rightCenter,
+            size: ctrlSize
         },
         top: {
             type: 'top',
             vertexes: topVertexes,
-            center: topCenter
+            center: topCenter,
+            size: ctrlSize
         },
         bottom: {
             type: 'bottom',
             vertexes: bottomVertexes,
-            center: bottomCenter
+            center: bottomCenter,
+            size: ctrlSize
         },
         topLeft: {
             type: 'top-left',
             vertexes: topLeftVertexes,
-            center: topLeftCenter
+            center: topLeftCenter,
+            size: ctrlSize
         },
         topRight: {
             type: 'top-right',
             vertexes: topRightVertexes,
-            center: topRightCenter
+            center: topRightCenter,
+            size: ctrlSize
         },
         bottomLeft: {
             type: 'bottom-left',
             vertexes: bottomLeftVertexes,
-            center: bottomLeftCenter
+            center: bottomLeftCenter,
+            size: ctrlSize
         },
         bottomRight: {
             type: 'bottom-right',
             vertexes: bottomRightVertexes,
-            center: bottomRightCenter
+            center: bottomRightCenter,
+            size: ctrlSize
         },
         leftMiddle: {
             type: 'left-middle',
             vertexes: leftMiddleVertexes,
-            center: leftCenter
+            center: leftCenter,
+            size: ctrlSize
         },
         rightMiddle: {
             type: 'right-middle',
             vertexes: rightMiddleVertexes,
-            center: rightCenter
+            center: rightCenter,
+            size: ctrlSize
         },
         topMiddle: {
             type: 'top-middle',
             vertexes: topMiddleVertexes,
-            center: topCenter
+            center: topCenter,
+            size: ctrlSize
         },
         bottomMiddle: {
             type: 'bottom-middle',
             vertexes: bottomMiddleVertexes,
-            center: bottomCenter
+            center: bottomCenter,
+            size: ctrlSize
         }
     };
     return sizeController;

package/dist/esm/lib/element.d.ts

@@ -29,3 +29,6 @@ export declare function findElementsFromListByPositions(positions: ElementPositi
 export declare function findElementFromListByPosition(position: ElementPosition, list: Element[]): Element | null;
 export declare function findElementQueueFromListByPosition(position: ElementPosition, list: Element[]): Element[];
 export declare function getElementPositionFromList(uuid: string, elements: Element<ElementType>[]): ElementPosition;
+export declare function getElementPositionMapFromList(uuids: string[], elements: Element<ElementType>[]): {
+    [uuid: string]: ElementPosition;
+};

package/dist/esm/lib/element.js

@@ -427,3 +427,34 @@ export function getElementPositionFromList(uuid, elements) {
     _loop(elements);
     return result;
 }
+export function getElementPositionMapFromList(uuids, elements) {
+    const currentPosition = [];
+    const positionMap = {};
+    let over = false;
+    const _loop = (list) => {
+        var _a;
+        for (let i = 0; i < list.length; i++) {
+            if (over === true) {
+                break;
+            }
+            currentPosition.push(i);
+            const elem = list[i];
+            if (uuids.includes(elem.uuid)) {
+                positionMap[elem.uuid] = [...currentPosition];
+                if (Object.keys(positionMap).length === uuids.length) {
+                    over = true;
+                    break;
+                }
+            }
+            else if (elem.type === 'group') {
+                _loop(((_a = elem === null || elem === void 0 ? void 0 : elem.detail) === null || _a === void 0 ? void 0 : _a.children) || []);
+            }
+            if (over) {
+                break;
+            }
+            currentPosition.pop();
+        }
+    };
+    _loop(elements);
+    return positionMap;
+}

package/dist/esm/lib/group.d.ts

@@ -0,0 +1,3 @@
+import type { Elements, ElementPosition } from '@idraw/types';
+export declare function groupElementsByPosition(list: Elements, positions: ElementPosition[]): Elements;
+export declare function ungroupElementsByPosition(list: Elements, position: ElementPosition): Elements;

package/dist/esm/lib/group.js

@@ -0,0 +1,81 @@
+import { findElementFromListByPosition, calcElementListSize } from './element';
+import { deleteElementInListByPosition, insertElementToListByPosition } from './handle-element';
+import { createUUID } from './uuid';
+export function groupElementsByPosition(list, positions) {
+    if (positions.length > 1) {
+        let isValidPositions = true;
+        let lastIndexs = [];
+        for (let i = 1; i < positions.length; i++) {
+            const prevPosition = positions[i - 1];
+            const position = positions[i];
+            if (!(prevPosition.length > 0 && position.length > 0)) {
+                isValidPositions = false;
+                break;
+            }
+            if (prevPosition.length !== position.length) {
+                isValidPositions = false;
+                break;
+            }
+            const temp1 = [...prevPosition];
+            const temp2 = [...position];
+            const lastIndex1 = temp1.pop();
+            const lastIndex2 = temp2.pop();
+            if (i === 1 && typeof lastIndex1 === 'number' && lastIndex1 >= 0) {
+                lastIndexs.push(lastIndex1);
+            }
+            if (typeof lastIndex2 === 'number' && lastIndex2 >= 0) {
+                lastIndexs.push(lastIndex2);
+            }
+        }
+        if (isValidPositions !== true) {
+            console.error('[idraw]: The grouped elements are not siblings!');
+            return list;
+        }
+        lastIndexs.sort((a, b) => a - b);
+        const groupParentPosition = [...positions[0]].splice(0, positions[0].length - 1);
+        const groupChildren = [];
+        const groupPosition = [...groupParentPosition, lastIndexs[0]];
+        for (let i = 0; i < lastIndexs.length; i++) {
+            const position = [...groupParentPosition, lastIndexs[i]];
+            const elem = findElementFromListByPosition(position, list);
+            if (elem) {
+                groupChildren.push(elem);
+            }
+        }
+        const groupSize = calcElementListSize(groupChildren);
+        for (let i = 0; i < groupChildren.length; i++) {
+            const elem = groupChildren[i];
+            if (elem) {
+                elem.x -= groupSize.x;
+                elem.y -= groupSize.y;
+            }
+        }
+        for (let i = lastIndexs.length - 1; i >= 0; i--) {
+            const position = [...groupParentPosition, lastIndexs[i]];
+            deleteElementInListByPosition(position, list);
+        }
+        const group = Object.assign(Object.assign({ name: 'Group', uuid: createUUID(), type: 'group' }, groupSize), { detail: {
+                children: groupChildren
+            } });
+        insertElementToListByPosition(group, groupPosition, list);
+    }
+    return list;
+}
+export function ungroupElementsByPosition(list, position) {
+    var _a;
+    const elem = findElementFromListByPosition(position, list);
+    if (!(elem && (elem === null || elem === void 0 ? void 0 : elem.type) === 'group' && Array.isArray((_a = elem === null || elem === void 0 ? void 0 : elem.detail) === null || _a === void 0 ? void 0 : _a.children))) {
+        console.error('[idraw]: The ungrouped element is not a group element!');
+    }
+    const groupParentPosition = [...position].splice(0, position.length - 1);
+    const groupLastIndex = position[position.length - 1];
+    const { x, y } = elem;
+    deleteElementInListByPosition(position, list);
+    elem.detail.children.forEach((child, i) => {
+        child.x += x;
+        child.y += y;
+        const elemPosition = [...groupParentPosition, groupLastIndex + i];
+        insertElementToListByPosition(child, elemPosition, list);
+    });
+    return list;
+}

package/dist/esm/lib/is.d.ts

@@ -12,7 +12,7 @@ declare function imageBase64(value: any): boolean;
 declare function imageSrc(value: any): boolean;
 declare function svg(value: any): boolean;
 declare function html(value: any): boolean;
-declare function text(value: any): boolean;
+declare function text(value: any): value is string;
 declare function fontSize(value: any): boolean;
 declare function lineHeight(value: any): boolean;
 declare function strokeWidth(value: any): boolean;

package/dist/esm/lib/rotate.js

@@ -46,18 +46,10 @@ export function calcElementCenterFromVertexes(ves) {
     return calcElementCenter(elemSize);
 }
 export function calcRadian(center, start, end) {
-    const startAngle = calcLineRadian(center, start);
-    const endAngle = calcLineRadian(center, end);
-    if (endAngle !== null && startAngle !== null) {
-        if (startAngle > (Math.PI * 3) / 2 && endAngle < Math.PI / 2) {
-            return endAngle + (Math.PI * 2 - startAngle);
-        }
-        else if (endAngle > (Math.PI * 3) / 2 && startAngle < Math.PI / 2) {
-            return startAngle + (Math.PI * 2 - endAngle);
-        }
-        else {
-            return endAngle - startAngle;
-        }
+    const startRadian = calcLineRadian(center, start);
+    const endRadian = calcLineRadian(center, end);
+    if (endRadian !== null && startRadian !== null) {
+        return endRadian - startRadian;
     }
     else {
         return 0;
@@ -199,12 +191,15 @@ export function rotateVertexes(center, ves, radian) {
     ];
 }
 export function limitAngle(angle) {
-    if (!(angle > 0 || angle < 0) || angle === 0) {
+    if (!(angle > 0 || angle < 0) || angle === 0 || angle === 360) {
         return 0;
     }
     let num = angle % 360;
     if (num < 0) {
         num += 360;
     }
+    else if (angle === 360) {
+        num = 0;
+    }
     return num;
 }

package/dist/esm/lib/store.d.ts

@@ -1,10 +1,13 @@
-export declare class Store<T extends Record<string | symbol, any> = Record<string | symbol, any>> {
+export declare class Store<T extends Record<string | symbol, any> = Record<string | symbol, any>, S extends Record<string | symbol, any> = Record<string | symbol, any>> {
     #private;
     constructor(opts: {
         defaultStorage: T;
+        defaultStatic?: S;
     });
     set<K extends keyof T>(name: K, value: T[K]): void;
     get<K extends keyof T>(name: K): T[K];
+    setStatic<K extends keyof S>(name: K, value: S[K]): void;
+    getStatic<K extends keyof S>(name: K): S[K] | undefined;
     getSnapshot(opts?: {
         deepClone?: boolean;
     }): T;

package/dist/esm/lib/store.js

@@ -9,15 +9,17 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Store_instances, _Store_temp, _Store_backUpDefaultStorage, _Store_createTempStorage;
+var _Store_instances, _Store_temp, _Store_backUpDefaultStorage, _Store_static, _Store_createTempStorage;
 import { deepClone } from './data';
 export class Store {
     constructor(opts) {
         _Store_instances.add(this);
         _Store_temp.set(this, void 0);
         _Store_backUpDefaultStorage.set(this, void 0);
+        _Store_static.set(this, void 0);
         __classPrivateFieldSet(this, _Store_backUpDefaultStorage, deepClone(opts.defaultStorage), "f");
         __classPrivateFieldSet(this, _Store_temp, __classPrivateFieldGet(this, _Store_instances, "m", _Store_createTempStorage).call(this), "f");
+        __classPrivateFieldSet(this, _Store_static, opts.defaultStatic || {}, "f");
     }
     set(name, value) {
         __classPrivateFieldGet(this, _Store_temp, "f")[name] = value;
@@ -25,6 +27,12 @@ export class Store {
     get(name) {
         return __classPrivateFieldGet(this, _Store_temp, "f")[name];
     }
+    setStatic(name, value) {
+        __classPrivateFieldGet(this, _Store_static, "f")[name] = value;
+    }
+    getStatic(name) {
+        return __classPrivateFieldGet(this, _Store_static, "f")[name];
+    }
     getSnapshot(opts) {
         if ((opts === null || opts === void 0 ? void 0 : opts.deepClone) === true) {
             return deepClone(__classPrivateFieldGet(this, _Store_temp, "f"));
@@ -36,8 +44,9 @@ export class Store {
     }
     destroy() {
         __classPrivateFieldSet(this, _Store_temp, null, "f");
+        __classPrivateFieldSet(this, _Store_static, null, "f");
     }
 }
-_Store_temp = new WeakMap(), _Store_backUpDefaultStorage = new WeakMap(), _Store_instances = new WeakSet(), _Store_createTempStorage = function _Store_createTempStorage() {
+_Store_temp = new WeakMap(), _Store_backUpDefaultStorage = new WeakMap(), _Store_static = new WeakMap(), _Store_instances = new WeakSet(), _Store_createTempStorage = function _Store_createTempStorage() {
     return deepClone(__classPrivateFieldGet(this, _Store_backUpDefaultStorage, "f"));
 };