@idraw/util 0.4.0-beta.4 → 0.4.0-beta.40

package/dist/esm/lib/controller.js

@@ -1,6 +1,8 @@
 import { createUUID } from './uuid';
 import { getCenterFromTwoPoints } from './point';
 import { calcElementVertexesInGroup, calcElementVertexes } from './vertex';
+import { calcViewElementSize } from './view-calc';
+import { calcElementCenter } from './rotate';
 function createControllerElementSizeFromCenter(center, opts) {
     const { x, y } = center;
     const { size, angle } = opts;
@@ -13,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 = [
         ...[
             {
@@ -36,6 +40,13 @@ export function calcElementSizeController(elemSize, opts) {
         totalAngle += angle;
     });
     const vertexes = calcElementVertexesInGroup(elemSize, { groupQueue });
+    const rotateElemVertexes = calcElementVertexesInGroup({
+        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]);
     const rightCenter = getCenterFromTwoPoints(vertexes[1], vertexes[2]);
     const bottomCenter = getCenterFromTwoPoints(vertexes[2], vertexes[3]);
@@ -44,6 +55,10 @@ export function calcElementSizeController(elemSize, opts) {
     const topRightCenter = vertexes[1];
     const bottomRightCenter = vertexes[2];
     const bottomLeftCenter = vertexes[3];
+    const topMiddleSize = createControllerElementSizeFromCenter(topCenter, { size: ctrlSize, angle: totalAngle });
+    const rightMiddleSize = createControllerElementSizeFromCenter(rightCenter, { size: ctrlSize, angle: totalAngle });
+    const bottomMiddleSize = createControllerElementSizeFromCenter(bottomCenter, { size: ctrlSize, angle: totalAngle });
+    const leftMiddleSize = createControllerElementSizeFromCenter(leftCenter, { size: ctrlSize, angle: totalAngle });
     const topLeftSize = createControllerElementSizeFromCenter(topLeftCenter, { size: ctrlSize, angle: totalAngle });
     const topRightSize = createControllerElementSizeFromCenter(topRightCenter, { size: ctrlSize, angle: totalAngle });
     const bottomLeftSize = createControllerElementSizeFromCenter(bottomLeftCenter, { size: ctrlSize, angle: totalAngle });
@@ -56,47 +71,207 @@ export function calcElementSizeController(elemSize, opts) {
     const rightVertexes = [topRightVertexes[3], topRightVertexes[2], bottomRightVertexes[1], bottomRightVertexes[0]];
     const bottomVertexes = [bottomLeftVertexes[1], bottomRightVertexes[0], bottomRightVertexes[3], bottomLeftVertexes[2]];
     const leftVertexes = [topLeftVertexes[3], topLeftVertexes[2], bottomLeftVertexes[1], bottomLeftVertexes[0]];
+    const topMiddleVertexes = calcElementVertexes(topMiddleSize);
+    const rightMiddleVertexes = calcElementVertexes(rightMiddleSize);
+    const bottomMiddleVertexes = calcElementVertexes(bottomMiddleSize);
+    const leftMiddleVertexes = calcElementVertexes(leftMiddleSize);
+    const rotateCenter = getCenterFromTwoPoints(rotateElemVertexes[0], rotateElemVertexes[1]);
+    const tempRotateSizeRepairRatio = 1.1;
+    const rotateSize = createControllerElementSizeFromCenter(rotateCenter, {
+        size: (rotateControllerSize * tempRotateSizeRepairRatio) / viewScaleInfo.scale,
+        angle: totalAngle
+    });
+    const rotateVertexes = calcElementVertexes(rotateSize);
     const sizeController = {
+        originalElementCenter: calcElementCenter(elemSize),
+        originalElementSize: Object.assign({}, elemSize),
         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,
+            size: ctrlSize
+        },
+        rightMiddle: {
+            type: 'right-middle',
+            vertexes: rightMiddleVertexes,
+            center: rightCenter,
+            size: ctrlSize
+        },
+        topMiddle: {
+            type: 'top-middle',
+            vertexes: topMiddleVertexes,
+            center: topCenter,
+            size: ctrlSize
+        },
+        bottomMiddle: {
+            type: 'bottom-middle',
+            vertexes: bottomMiddleVertexes,
+            center: bottomCenter,
+            size: ctrlSize
+        },
+        rotate: {
+            type: 'rotate',
+            vertexes: rotateVertexes,
+            center: rotateCenter,
+            size: rotateControllerSize
+        }
+    };
+    return sizeController;
+}
+export function calcLayoutSizeController(layoutSize, opts) {
+    const { controllerSize, viewScaleInfo } = opts;
+    const ctrlSize = controllerSize && controllerSize > 0 ? controllerSize : 8;
+    const { x, y, w, h } = calcViewElementSize(layoutSize, { viewScaleInfo });
+    const center = calcElementCenter({ x, y, w, h });
+    const topCenter = { x: center.x, y };
+    const rightCenter = { x: x + w, y: center.y };
+    const bottomCenter = { x: center.x, y: y + h };
+    const leftCenter = { x, y: center.y };
+    const topLeftCenter = { x, y };
+    const topRightCenter = { x: x + w, y };
+    const bottomRightCenter = { x: x + w, y: y + h };
+    const bottomLeftCenter = { x, y: y + h };
+    const topMiddleSize = createControllerElementSizeFromCenter(topCenter, { size: ctrlSize, angle: 0 });
+    const rightMiddleSize = createControllerElementSizeFromCenter(rightCenter, { size: ctrlSize, angle: 0 });
+    const bottomMiddleSize = createControllerElementSizeFromCenter(bottomCenter, { size: ctrlSize, angle: 0 });
+    const leftMiddleSize = createControllerElementSizeFromCenter(leftCenter, { size: ctrlSize, angle: 0 });
+    const topLeftSize = createControllerElementSizeFromCenter(topLeftCenter, { size: ctrlSize, angle: 0 });
+    const topRightSize = createControllerElementSizeFromCenter(topRightCenter, { size: ctrlSize, angle: 0 });
+    const bottomLeftSize = createControllerElementSizeFromCenter(bottomLeftCenter, { size: ctrlSize, angle: 0 });
+    const bottomRightSize = createControllerElementSizeFromCenter(bottomRightCenter, { size: ctrlSize, angle: 0 });
+    const topLeftVertexes = calcElementVertexes(topLeftSize);
+    const topRightVertexes = calcElementVertexes(topRightSize);
+    const bottomLeftVertexes = calcElementVertexes(bottomLeftSize);
+    const bottomRightVertexes = calcElementVertexes(bottomRightSize);
+    const topVertexes = [topLeftVertexes[1], topRightVertexes[0], topRightVertexes[3], topLeftVertexes[2]];
+    const rightVertexes = [topRightVertexes[3], topRightVertexes[2], bottomRightVertexes[1], bottomRightVertexes[0]];
+    const bottomVertexes = [bottomLeftVertexes[1], bottomRightVertexes[0], bottomRightVertexes[3], bottomLeftVertexes[2]];
+    const leftVertexes = [topLeftVertexes[3], topLeftVertexes[2], bottomLeftVertexes[1], bottomLeftVertexes[0]];
+    const topMiddleVertexes = calcElementVertexes(topMiddleSize);
+    const rightMiddleVertexes = calcElementVertexes(rightMiddleSize);
+    const bottomMiddleVertexes = calcElementVertexes(bottomMiddleSize);
+    const leftMiddleVertexes = calcElementVertexes(leftMiddleSize);
+    const sizeController = {
+        left: {
+            type: 'left',
+            vertexes: leftVertexes,
+            center: leftCenter,
+            size: ctrlSize
+        },
+        right: {
+            type: 'right',
+            vertexes: rightVertexes,
+            center: rightCenter,
+            size: ctrlSize
+        },
+        top: {
+            type: 'top',
+            vertexes: topVertexes,
+            center: topCenter,
+            size: ctrlSize
+        },
+        bottom: {
+            type: 'bottom',
+            vertexes: bottomVertexes,
+            center: bottomCenter,
+            size: ctrlSize
+        },
+        topLeft: {
+            type: 'top-left',
+            vertexes: topLeftVertexes,
+            center: topLeftCenter,
+            size: ctrlSize
+        },
+        topRight: {
+            type: 'top-right',
+            vertexes: topRightVertexes,
+            center: topRightCenter,
+            size: ctrlSize
+        },
+        bottomLeft: {
+            type: 'bottom-left',
+            vertexes: bottomLeftVertexes,
+            center: bottomLeftCenter,
+            size: ctrlSize
+        },
+        bottomRight: {
+            type: 'bottom-right',
+            vertexes: bottomRightVertexes,
+            center: bottomRightCenter,
+            size: ctrlSize
+        },
+        leftMiddle: {
+            type: 'left-middle',
+            vertexes: leftMiddleVertexes,
+            center: leftCenter,
+            size: ctrlSize
+        },
+        rightMiddle: {
+            type: 'right-middle',
+            vertexes: rightMiddleVertexes,
+            center: rightCenter,
+            size: ctrlSize
+        },
+        topMiddle: {
+            type: 'top-middle',
+            vertexes: topMiddleVertexes,
+            center: topCenter,
+            size: ctrlSize
+        },
+        bottomMiddle: {
+            type: 'bottom-middle',
+            vertexes: bottomMiddleVertexes,
+            center: bottomCenter,
+            size: ctrlSize
         }
     };
     return sizeController;

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

@@ -1,5 +1,10 @@
-import type { Data } from '@idraw/types';
-export declare function deepClone<T extends any = any>(target: T): T;
+import type { Data, Element, LoadItemMap } from '@idraw/types';
+export declare function deepClone<T = any>(target: T): T;
+export declare function deepCloneElement<T extends Element = Element>(element: T): T;
+export declare function deepCloneData(data: Data): Data;
 export declare function sortDataAsserts(data: Data, opts?: {
     clone?: boolean;
 }): Data;
+export declare function filterCompactData(data: Data, opts?: {
+    loadItemMap?: LoadItemMap;
+}): Data<Record<string, any>>;

package/dist/esm/lib/data.js

@@ -1,4 +1,15 @@
-import { createAssetId } from './uuid';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { createAssetId, createUUID, isAssetId } from './uuid';
 export function deepClone(target) {
     function _clone(t) {
         const type = is(t);
@@ -27,11 +38,30 @@ export function deepClone(target) {
     }
     return _clone(target);
 }
+export function deepCloneElement(element) {
+    const elem = deepClone(element);
+    const _resetUUID = (e) => {
+        e.uuid = createUUID();
+        if (e.type === 'group' && e.detail.children) {
+            e.detail.children.forEach((child) => {
+                _resetUUID(child);
+            });
+        }
+    };
+    _resetUUID(elem);
+    return elem;
+}
+export function deepCloneData(data) {
+    const { elements } = data, restData = __rest(data, ["elements"]);
+    return Object.assign(Object.assign({}, deepClone(restData)), {
+        elements: elements.map((elem) => deepCloneElement(elem))
+    });
+}
 function is(target) {
-    return Object.prototype.toString
+    return (Object.prototype.toString
         .call(target)
         .replace(/[\]|\[]{1,1}/gi, '')
-        .split(' ')[1];
+        .split(' ')[1]);
 }
 export function sortDataAsserts(data, opts) {
     const assets = data.assets || {};
@@ -68,7 +98,7 @@ export function sortDataAsserts(data, opts) {
                 const assetUUID = createAssetId(html);
                 if (!assets[assetUUID]) {
                     assets[assetUUID] = {
-                        type: 'svg',
+                        type: 'html',
                         value: html
                     };
                 }
@@ -90,3 +120,83 @@ export function sortDataAsserts(data, opts) {
     sortedData.assets = assets;
     return sortedData;
 }
+export function filterCompactData(data, opts) {
+    const assets = data.assets || {};
+    const sortedData = deepClone(data);
+    const loadItemMap = (opts === null || opts === void 0 ? void 0 : opts.loadItemMap) || {};
+    const _scanElements = (elems) => {
+        elems.forEach((elem) => {
+            var _a, _b, _c;
+            if (elem.type === 'image' && elem.detail.src) {
+                const src = elem.detail.src;
+                if (isAssetId(src) && !assets[src] && loadItemMap[src] && typeof ((_a = loadItemMap[src]) === null || _a === void 0 ? void 0 : _a.source) === 'string') {
+                    assets[src] = {
+                        type: 'image',
+                        value: loadItemMap[src].source
+                    };
+                }
+                else if (!assets[src]) {
+                    const assetUUID = createAssetId(src);
+                    if (!assets[assetUUID]) {
+                        assets[assetUUID] = {
+                            type: 'image',
+                            value: src
+                        };
+                    }
+                    elem.detail.src = assetUUID;
+                }
+            }
+            else if (elem.type === 'svg') {
+                const svg = elem.detail.svg;
+                if (isAssetId(svg) && !assets[svg] && loadItemMap[svg] && typeof ((_b = loadItemMap[svg]) === null || _b === void 0 ? void 0 : _b.source) === 'string') {
+                    assets[svg] = {
+                        type: 'svg',
+                        value: loadItemMap[svg].source
+                    };
+                }
+                else if (!assets[svg]) {
+                    const assetUUID = createAssetId(svg);
+                    if (!assets[assetUUID]) {
+                        assets[assetUUID] = {
+                            type: 'svg',
+                            value: svg
+                        };
+                    }
+                    elem.detail.svg = assetUUID;
+                }
+            }
+            else if (elem.type === 'html') {
+                const html = elem.detail.html;
+                if (isAssetId(html) && !assets[html] && loadItemMap[html] && typeof ((_c = loadItemMap[html]) === null || _c === void 0 ? void 0 : _c.source) === 'string') {
+                    assets[html] = {
+                        type: 'html',
+                        value: loadItemMap[html].source
+                    };
+                }
+                else if (!assets[html]) {
+                    const assetUUID = createAssetId(html);
+                    if (!assets[assetUUID]) {
+                        assets[assetUUID] = {
+                            type: 'html',
+                            value: html
+                        };
+                    }
+                    elem.detail.html = assetUUID;
+                }
+            }
+            else if (elem.type === 'group' && Array.isArray(elem.detail.children)) {
+                const groupAssets = elem.detail.assets || {};
+                Object.keys(groupAssets).forEach((assetId) => {
+                    if (!assets[assetId]) {
+                        assets[assetId] = groupAssets[assetId];
+                    }
+                });
+                delete elem.detail.assets;
+                _scanElements(elem.detail.children);
+            }
+        });
+    };
+    _scanElements(sortedData.elements);
+    sortedData.assets = assets;
+    return sortedData;
+}

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

@@ -16,6 +16,7 @@ export declare function getElemenetsAssetIds(elements: Elements): string[];
 export declare function findElementFromList(uuid: string, list: Element<ElementType>[]): Element<ElementType> | null;
 export declare function findElementsFromList(uuids: string[], list: Element<ElementType>[]): Element<ElementType>[];
 export declare function getGroupQueueFromList(uuid: string, elements: Element<ElementType>[]): Element<'group'>[];
+export declare function getGroupQueueByElementPosition(elements: Element<ElementType>[], position: ElementPosition): Element<'group'>[] | null;
 export declare function getElementSize(elem: Element): ElementSize;
 export declare function mergeElementAsset<T extends Element<LoadElementType>>(element: T, assets: ElementAssets): T;
 export declare function filterElementAsset<T extends Element<LoadElementType>>(element: T): {
@@ -28,3 +29,7 @@ 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;
+};
+export declare function isSameElementSize(elem1: ElementSize, elem2: ElementSize): boolean;

package/dist/esm/lib/element.js

@@ -1,4 +1,4 @@
-import { rotateElementVertexes } from './rotate';
+import { limitAngle, rotateElementVertexes } from './rotate';
 import { isAssetId, createAssetId } from './uuid';
 function getGroupUUIDs(elements, index) {
     var _a;
@@ -260,6 +260,25 @@ export function getGroupQueueFromList(uuid, elements) {
     _scan(uuid, elements);
     return groupQueue;
 }
+export function getGroupQueueByElementPosition(elements, position) {
+    var _a;
+    const groupQueue = [];
+    let currentElements = elements;
+    if (position.length > 1) {
+        for (let i = 0; i < position.length - 1; i++) {
+            const index = position[i];
+            const group = currentElements[index];
+            if ((group === null || group === void 0 ? void 0 : group.type) === 'group' && Array.isArray((_a = group === null || group === void 0 ? void 0 : group.detail) === null || _a === void 0 ? void 0 : _a.children)) {
+                groupQueue.push(group);
+                currentElements = group.detail.children;
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    return groupQueue;
+}
 export function getElementSize(elem) {
     const { x, y, w, h, angle } = elem;
     const size = { x, y, w, h, angle };
@@ -408,3 +427,37 @@ 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;
+}
+export function isSameElementSize(elem1, elem2) {
+    return (elem1.x === elem2.x && elem1.y === elem2.y && elem1.h === elem2.h && elem1.w === elem2.w && limitAngle(elem1.angle || 0) === limitAngle(elem2.angle || 0));
+}

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

@@ -1,9 +1,11 @@
 import type { UtilEventEmitter } from '@idraw/types';
 export declare class EventEmitter<T extends Record<string, any>> implements UtilEventEmitter<T> {
-    private _listeners;
+    #private;
     constructor();
     on<K extends keyof T>(eventKey: K, callback: (e: T[K]) => void): void;
     off<K extends keyof T>(eventKey: K, callback: (e: T[K]) => void): void;
-    trigger<K extends keyof T>(eventKey: K, e: T[K]): boolean;
+    trigger<K extends keyof T>(eventKey: K, e?: T[K]): boolean;
     has<K extends keyof T>(name: K | string): boolean;
+    destroy(): void;
+    clear(): void;
 }

package/dist/esm/lib/event.js

@@ -1,20 +1,33 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _EventEmitter_listeners;
 export class EventEmitter {
     constructor() {
-        this._listeners = new Map();
+        _EventEmitter_listeners.set(this, void 0);
+        __classPrivateFieldSet(this, _EventEmitter_listeners, new Map(), "f");
     }
     on(eventKey, callback) {
-        if (this._listeners.has(eventKey)) {
-            const callbacks = this._listeners.get(eventKey) || [];
+        if (__classPrivateFieldGet(this, _EventEmitter_listeners, "f").has(eventKey)) {
+            const callbacks = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(eventKey) || [];
             callbacks === null || callbacks === void 0 ? void 0 : callbacks.push(callback);
-            this._listeners.set(eventKey, callbacks);
+            __classPrivateFieldGet(this, _EventEmitter_listeners, "f").set(eventKey, callbacks);
         }
         else {
-            this._listeners.set(eventKey, [callback]);
+            __classPrivateFieldGet(this, _EventEmitter_listeners, "f").set(eventKey, [callback]);
         }
     }
     off(eventKey, callback) {
-        if (this._listeners.has(eventKey)) {
-            const callbacks = this._listeners.get(eventKey);
+        if (__classPrivateFieldGet(this, _EventEmitter_listeners, "f").has(eventKey)) {
+            const callbacks = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(eventKey);
             if (Array.isArray(callbacks)) {
                 for (let i = 0; i < (callbacks === null || callbacks === void 0 ? void 0 : callbacks.length); i++) {
                     if (callbacks[i] === callback) {
@@ -23,11 +36,11 @@ export class EventEmitter {
                     }
                 }
             }
-            this._listeners.set(eventKey, callbacks || []);
+            __classPrivateFieldGet(this, _EventEmitter_listeners, "f").set(eventKey, callbacks || []);
         }
     }
     trigger(eventKey, e) {
-        const callbacks = this._listeners.get(eventKey);
+        const callbacks = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(eventKey);
         if (Array.isArray(callbacks)) {
             callbacks.forEach((cb) => {
                 cb(e);
@@ -39,12 +52,19 @@ export class EventEmitter {
         }
     }
     has(name) {
-        if (this._listeners.has(name)) {
-            const list = this._listeners.get(name);
+        if (__classPrivateFieldGet(this, _EventEmitter_listeners, "f").has(name)) {
+            const list = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(name);
             if (Array.isArray(list) && list.length > 0) {
                 return true;
             }
         }
         return false;
     }
+    destroy() {
+        this.clear();
+    }
+    clear() {
+        __classPrivateFieldGet(this, _EventEmitter_listeners, "f").clear();
+    }
 }
+_EventEmitter_listeners = new WeakMap();

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

@@ -4,10 +4,11 @@ export declare function downloadImageFromCanvas(canvas: HTMLCanvasElement, opts:
     type: ImageType;
 }): void;
 export declare function pickFile(opts: {
+    accept?: string;
     success: (data: {
         file: File;
     }) => void;
-    error?: (err: ErrorEvent) => void;
+    error?: (err: Error | any) => void;
 }): void;
 export declare function parseFileToBase64(file: File): Promise<string | ArrayBuffer>;
 export declare function parseFileToText(file: File): Promise<string | ArrayBuffer>;

package/dist/esm/lib/file.js

@@ -8,9 +8,12 @@ export function downloadImageFromCanvas(canvas, opts) {
     downloadLink = null;
 }
 export function pickFile(opts) {
-    const { success, error } = opts;
+    const { accept, success, error } = opts;
     let input = document.createElement('input');
     input.type = 'file';
+    if (accept) {
+        input.accept = accept;
+    }
     input.addEventListener('change', function () {
         var _a;
         const file = (_a = input.files) === null || _a === void 0 ? void 0 : _a[0];

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

@@ -0,0 +1,2 @@
+import type { Elements } from '@idraw/types';
+export declare function flatElementList(list: Elements): Elements;