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

package/dist/esm/lib/modify-recorder.js

@@ -0,0 +1,177 @@
+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 _ModifyRecorder_instances, _ModifyRecorder_doStack, _ModifyRecorder_undoStack, _ModifyRecorder_opts, _ModifyRecorder_wrapRecord;
+import { deepClone } from './data';
+import { modifyElement } from './modify';
+export class ModifyRecorder {
+    constructor(opts) {
+        _ModifyRecorder_instances.add(this);
+        _ModifyRecorder_doStack.set(this, []);
+        _ModifyRecorder_undoStack.set(this, []);
+        _ModifyRecorder_opts.set(this, void 0);
+        __classPrivateFieldSet(this, _ModifyRecorder_opts, opts, "f");
+    }
+    $getDoStack() {
+        return __classPrivateFieldGet(this, _ModifyRecorder_doStack, "f");
+    }
+    $getUndoStack() {
+        return __classPrivateFieldGet(this, _ModifyRecorder_undoStack, "f");
+    }
+    clear() {
+        __classPrivateFieldSet(this, _ModifyRecorder_doStack, [], "f");
+        __classPrivateFieldSet(this, _ModifyRecorder_undoStack, [], "f");
+    }
+    destroy() {
+        this.clear();
+        __classPrivateFieldSet(this, _ModifyRecorder_doStack, null, "f");
+        __classPrivateFieldSet(this, _ModifyRecorder_undoStack, null, "f");
+    }
+    do(data, opts) {
+        const { data: modifiedData, content } = modifyElement(data, opts);
+        if (__classPrivateFieldGet(this, _ModifyRecorder_opts, "f").recordable === true) {
+            const record = __classPrivateFieldGet(this, _ModifyRecorder_instances, "m", _ModifyRecorder_wrapRecord).call(this, opts, content);
+            __classPrivateFieldGet(this, _ModifyRecorder_doStack, "f").push(record);
+        }
+        return modifiedData;
+    }
+    undo(data) {
+        if (__classPrivateFieldGet(this, _ModifyRecorder_opts, "f").recordable !== true) {
+            return null;
+        }
+        let modifiedData = null;
+        if (__classPrivateFieldGet(this, _ModifyRecorder_doStack, "f").length === 0) {
+            return data;
+        }
+        const item = __classPrivateFieldGet(this, _ModifyRecorder_doStack, "f").pop();
+        if (!item) {
+            return data;
+        }
+        if ((item === null || item === void 0 ? void 0 : item.type) === 'addElement') {
+            const record = item;
+            const { position, element } = record;
+            modifiedData = modifyElement(data, {
+                type: 'deleteElement',
+                content: {
+                    position,
+                    element
+                }
+            }).data;
+        }
+        else if ((item === null || item === void 0 ? void 0 : item.type) === 'updateElement') {
+            const record = item;
+            const { position, beforeModifiedElement, afterModifiedElement } = record;
+            modifiedData = modifyElement(data, {
+                type: 'updateElement',
+                content: {
+                    position,
+                    beforeModifiedElement: afterModifiedElement,
+                    afterModifiedElement: beforeModifiedElement
+                }
+            }).data;
+        }
+        else if ((item === null || item === void 0 ? void 0 : item.type) === 'deleteElement') {
+            const record = item;
+            const { position, element } = record;
+            modifiedData = modifyElement(data, {
+                type: 'addElement',
+                content: {
+                    position,
+                    element
+                }
+            }).data;
+        }
+        else if ((item === null || item === void 0 ? void 0 : item.type) === 'moveElement') {
+            const record = item;
+            const { afterModifiedFrom, afterModifiedTo } = record;
+            const modifiedResult = modifyElement(data, {
+                type: 'moveElement',
+                content: {
+                    from: afterModifiedTo,
+                    to: afterModifiedFrom
+                }
+            });
+            modifiedData = modifiedResult.data;
+        }
+        __classPrivateFieldGet(this, _ModifyRecorder_undoStack, "f").push(deepClone(item));
+        return modifiedData;
+    }
+    redo(data) {
+        if (__classPrivateFieldGet(this, _ModifyRecorder_opts, "f").recordable !== true) {
+            return null;
+        }
+        let modifiedData = null;
+        if (__classPrivateFieldGet(this, _ModifyRecorder_undoStack, "f").length === 0) {
+            return modifiedData;
+        }
+        const item = __classPrivateFieldGet(this, _ModifyRecorder_undoStack, "f").pop();
+        if (!item) {
+            return modifiedData;
+        }
+        if ((item === null || item === void 0 ? void 0 : item.type) === 'addElement') {
+            const record = item;
+            const { position, element } = record;
+            modifiedData = modifyElement(data, {
+                type: 'addElement',
+                content: {
+                    position,
+                    element
+                }
+            }).data;
+        }
+        else if ((item === null || item === void 0 ? void 0 : item.type) === 'updateElement') {
+            const record = item;
+            const { position, beforeModifiedElement, afterModifiedElement } = record;
+            modifiedData = modifyElement(data, {
+                type: 'updateElement',
+                content: {
+                    position,
+                    beforeModifiedElement,
+                    afterModifiedElement
+                }
+            }).data;
+        }
+        else if ((item === null || item === void 0 ? void 0 : item.type) === 'deleteElement') {
+            const record = item;
+            const { position, element } = record;
+            modifiedData = modifyElement(data, {
+                type: 'deleteElement',
+                content: {
+                    position,
+                    element
+                }
+            }).data;
+        }
+        else if ((item === null || item === void 0 ? void 0 : item.type) === 'moveElement') {
+            const record = item;
+            const { from, to } = record;
+            modifiedData = modifyElement(data, {
+                type: 'moveElement',
+                content: {
+                    from,
+                    to
+                }
+            }).data;
+        }
+        __classPrivateFieldGet(this, _ModifyRecorder_doStack, "f").push(deepClone(item));
+        return modifiedData;
+    }
+}
+_ModifyRecorder_doStack = new WeakMap(), _ModifyRecorder_undoStack = new WeakMap(), _ModifyRecorder_opts = new WeakMap(), _ModifyRecorder_instances = new WeakSet(), _ModifyRecorder_wrapRecord = function _ModifyRecorder_wrapRecord(opts, modifiedContent) {
+    const content = opts.content;
+    const modifyRecord = Object.assign(Object.assign({}, deepClone(content)), { type: opts.type, time: Date.now() });
+    const record = modifyRecord;
+    if (opts.type === 'moveElement') {
+        modifyRecord.afterModifiedFrom = [...modifiedContent.from];
+        modifyRecord.afterModifiedTo = [...modifiedContent.to];
+    }
+    return record;
+};

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

@@ -0,0 +1,6 @@
+import { Data, Element, ModifyOptions, ModifyType, ModifyContentMap, ModifiedElement } from '@idraw/types';
+export declare function modifyElement<T extends ModifyType = ModifyType>(data: Data, options: ModifyOptions<T>): {
+    data: Data;
+    content: ModifyContentMap[T];
+};
+export declare function getModifiedElement(target: ModifiedElement, originElement: Element): ModifiedElement;

package/dist/esm/lib/modify.js

@@ -0,0 +1,99 @@
+import { insertElementToListByPosition, deleteElementInListByPosition, moveElementPosition, updateElementInListByPosition } from './handle-element';
+import { istype } from './istype';
+export function modifyElement(data, options) {
+    const { type } = options;
+    const content = Object.assign({}, options.content);
+    if (type === 'addElement') {
+        const opts = options;
+        const { element, position } = opts.content;
+        if ((position === null || position === void 0 ? void 0 : position.length) > 0) {
+            insertElementToListByPosition(element, [...position], data.elements);
+        }
+        else {
+            data.elements.push(element);
+        }
+    }
+    else if (type === 'deleteElement') {
+        const opts = options;
+        const { position } = opts.content;
+        deleteElementInListByPosition(position, data.elements);
+    }
+    else if (type === 'moveElement') {
+        const opts = options;
+        const { from, to } = opts.content;
+        const movedResult = moveElementPosition(data.elements, { from, to });
+        content.from = movedResult.from;
+        content.to = movedResult.to;
+        data.elements = movedResult.elements;
+    }
+    else if (type === 'updateElement') {
+        const opts = options;
+        const { position, afterModifiedElement } = opts.content;
+        updateElementInListByPosition(position, afterModifiedElement, data.elements);
+    }
+    return { data, content };
+}
+function _get(source, path, defaultValue = undefined) {
+    const keyList = path.split('.');
+    const result = keyList.reduce((obj, key) => {
+        return Object(obj)[key];
+    }, source);
+    return result === undefined ? defaultValue : result;
+}
+function _set(obj, path, value) {
+    const keys = path.split('.');
+    if (typeof obj !== 'object')
+        return obj;
+    keys.reduce((o, k, i, _) => {
+        if (i === _.length - 1) {
+            o[k] = value;
+            return null;
+        }
+        else if (k in o) {
+            return o[k];
+        }
+        else {
+            o[k] = /^[0-9]{1,}$/.test(_[i + 1]) ? [] : {};
+            return o[k];
+        }
+    }, obj);
+    return obj;
+}
+export function getModifiedElement(target, originElement) {
+    const modifiedElement = {};
+    const pathList = [];
+    const _walk = (t) => {
+        if (istype.json(t)) {
+            const keys = Object.keys(t);
+            keys.forEach((key) => {
+                pathList.push(key);
+                if (istype.json(t[key]) || istype.array(t[key])) {
+                    _walk(t[key]);
+                }
+                else {
+                    const pathStr = pathList.join('.');
+                    if (pathStr !== 'uuid') {
+                        const value = _get(originElement, pathStr);
+                        _set(modifiedElement, pathList.join('.'), value);
+                    }
+                }
+                pathList.pop();
+            });
+        }
+        else if (istype.array(t)) {
+            t.forEach((index) => {
+                pathList.push(index);
+                if (istype.json(t[index]) || istype.array(t[index])) {
+                    _walk(t[index]);
+                }
+                else {
+                    const value = _get(originElement, pathList.join('.'));
+                    _set(modifiedElement, pathList.join('.'), value);
+                }
+                pathList.pop();
+            });
+        }
+    };
+    _walk(target);
+    return modifiedElement;
+}

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

@@ -0,0 +1 @@
+export declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

package/dist/esm/lib/omit.js

@@ -0,0 +1,7 @@
+export function omit(obj, keys) {
+    const result = Object.assign({}, obj);
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
+}

package/dist/esm/lib/point-move-element.d.ts

@@ -0,0 +1,5 @@
+import type { PointSize, Element } from '@idraw/types';
+export declare function calcPointMoveElementInGroup(start: PointSize, end: PointSize, groupQueue: Element<'group'>[]): {
+    moveX: number;
+    moveY: number;
+};

package/dist/esm/lib/point-move-element.js

@@ -0,0 +1,26 @@
+import { rotatePointInGroup } from './rotate';
+export function calcPointMoveElementInGroup(start, end, groupQueue) {
+    let moveX = end.x - start.x;
+    let moveY = end.y - start.y;
+    const pointGroupQueue = [];
+    groupQueue.forEach((group) => {
+        const { x, y, w, h, angle = 0 } = group;
+        pointGroupQueue.push({
+            x,
+            y,
+            w,
+            h,
+            angle: 0 - angle
+        });
+    });
+    if ((groupQueue === null || groupQueue === void 0 ? void 0 : groupQueue.length) > 0) {
+        const startInGroup = rotatePointInGroup(start, pointGroupQueue);
+        const endInGroup = rotatePointInGroup(end, pointGroupQueue);
+        moveX = endInGroup.x - startInGroup.x;
+        moveY = endInGroup.y - startInGroup.y;
+    }
+    return {
+        moveX,
+        moveY
+    };
+}

package/dist/esm/lib/rect.js

@@ -1,11 +1,11 @@
 export function checkRectIntersect(rect1, rect2) {
-    const react1MinX = rect1.x;
-    const react1MinY = rect1.y;
-    const react1MaxX = rect1.x + rect1.w;
-    const react1MaxY = rect1.y + rect1.h;
-    const react2MinX = rect2.x;
-    const react2MinY = rect2.y;
-    const react2MaxX = rect2.x + rect2.w;
-    const react2MaxY = rect2.y + rect2.h;
-    return react1MinX <= react2MaxX && react1MaxX >= react2MinX && react1MinY <= react2MaxY && react1MaxY >= react2MinY;
+    const rect1MinX = rect1.x;
+    const rect1MinY = rect1.y;
+    const rect1MaxX = rect1.x + rect1.w;
+    const rect1MaxY = rect1.y + rect1.h;
+    const rect2MinX = rect2.x;
+    const rect2MinY = rect2.y;
+    const rect2MaxX = rect2.x + rect2.w;
+    const rect2MaxY = rect2.y + rect2.h;
+    return rect1MinX <= rect2MaxX && rect1MaxX >= rect2MinX && rect1MinY <= rect2MaxY && rect1MaxY >= rect2MinY;
 }

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

@@ -0,0 +1,2 @@
+import type { Element, ElementSize } from '@idraw/types';
+export declare function deepResizeGroupElement(elem: Element<'group'>, size: Pick<Partial<ElementSize>, 'w' | 'h'>): Element<'group'>;

package/dist/esm/lib/resize-element.js

@@ -0,0 +1,101 @@
+import { formatNumber } from './number';
+const doNum = (n) => {
+    return formatNumber(n, { decimalPlaces: 4 });
+};
+function resizeElementBaseDetail(elem, opts) {
+    const { detail } = elem;
+    const { xRatio, yRatio, maxRatio } = opts;
+    const middleRatio = (xRatio + yRatio) / 2;
+    const { borderWidth, borderRadius, borderDash, shadowOffsetX, shadowOffsetY, shadowBlur } = detail;
+    if (typeof borderWidth === 'number') {
+        detail.borderWidth = doNum(borderWidth * middleRatio);
+    }
+    else if (Array.isArray(detail.borderWidth)) {
+        const bw = borderWidth;
+        detail.borderWidth = [doNum(bw[0] * yRatio), doNum(bw[1] * xRatio), doNum(bw[2] * yRatio), doNum(bw[3] * xRatio)];
+    }
+    if (typeof borderRadius === 'number') {
+        detail.borderRadius = doNum(borderRadius * middleRatio);
+    }
+    else if (Array.isArray(detail.borderRadius)) {
+        const br = borderRadius;
+        detail.borderRadius = [br[0] * xRatio, br[1] * xRatio, br[2] * yRatio, br[3] * yRatio];
+    }
+    if (Array.isArray(borderDash)) {
+        borderDash.forEach((dash, i) => {
+            detail.borderDash[i] = doNum(dash * maxRatio);
+        });
+    }
+    if (typeof shadowOffsetX === 'number') {
+        detail.shadowOffsetX = doNum(shadowOffsetX * maxRatio);
+    }
+    if (typeof shadowOffsetY === 'number') {
+        detail.shadowOffsetX = doNum(shadowOffsetY * maxRatio);
+    }
+    if (typeof shadowBlur === 'number') {
+        detail.shadowOffsetX = doNum(shadowBlur * maxRatio);
+    }
+}
+function resizeElementBase(elem, opts) {
+    const { xRatio, yRatio } = opts;
+    const { x, y, w, h } = elem;
+    elem.x = doNum(x * xRatio);
+    elem.y = doNum(y * yRatio);
+    elem.w = doNum(w * xRatio);
+    elem.h = doNum(h * yRatio);
+    resizeElementBaseDetail(elem, opts);
+}
+function resizeTextElementDetail(elem, opts) {
+    const { minRatio, maxRatio } = opts;
+    const { fontSize, lineHeight } = elem.detail;
+    const ratio = (minRatio + maxRatio) / 2;
+    if (fontSize && fontSize > 0) {
+        elem.detail.fontSize = doNum(fontSize * ratio);
+    }
+    if (lineHeight && lineHeight > 0) {
+        elem.detail.lineHeight = doNum(lineHeight * ratio);
+    }
+}
+function resizeElement(elem, opts) {
+    const { type } = elem;
+    resizeElementBase(elem, opts);
+    if (type === 'circle') {
+    }
+    else if (type === 'text') {
+        resizeTextElementDetail(elem, opts);
+    }
+    else if (type === 'image') {
+    }
+    else if (type === 'svg') {
+    }
+    else if (type === 'html') {
+    }
+    else if (type === 'path') {
+    }
+    else if (type === 'group' && Array.isArray(elem.detail.children)) {
+        elem.detail.children.forEach((child) => {
+            resizeElement(child, opts);
+        });
+    }
+}
+export function deepResizeGroupElement(elem, size) {
+    const resizeW = size.w && size.w > 0 ? size.w : elem.w;
+    const resizeH = size.h && size.h > 0 ? size.h : elem.h;
+    const xRatio = resizeW / elem.w;
+    const yRatio = resizeH / elem.h;
+    if (xRatio === yRatio && xRatio === 1) {
+        return elem;
+    }
+    const minRatio = Math.min(xRatio, yRatio);
+    const maxRatio = Math.max(xRatio, yRatio);
+    elem.w = resizeW;
+    elem.h = resizeH;
+    const opts = { xRatio, yRatio, minRatio, maxRatio };
+    if (elem.type === 'group' && Array.isArray(elem.detail.children)) {
+        elem.detail.children.forEach((child) => {
+            resizeElement(child, opts);
+        });
+    }
+    resizeElementBaseDetail(elem, opts);
+    return elem;
+}

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,12 +1,16 @@
-export declare class Store<T extends Record<string | symbol, any>> {
-    private _temp;
-    private _backUpDefaultStorage;
+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];
-    getSnapshot(): T;
+    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;
     clear(): void;
-    private _createTempStorage;
+    destroy(): void;
 }

package/dist/esm/lib/store.js

@@ -1,22 +1,52 @@
+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 _Store_instances, _Store_temp, _Store_backUpDefaultStorage, _Store_static, _Store_createTempStorage;
 import { deepClone } from './data';
 export class Store {
     constructor(opts) {
-        this._backUpDefaultStorage = deepClone(opts.defaultStorage);
-        this._temp = this._createTempStorage();
+        _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) {
-        this._temp[name] = value;
+        __classPrivateFieldGet(this, _Store_temp, "f")[name] = value;
     }
     get(name) {
-        return this._temp[name];
+        return __classPrivateFieldGet(this, _Store_temp, "f")[name];
     }
-    getSnapshot() {
-        return deepClone(this._temp);
+    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"));
+        }
+        return Object.assign({}, __classPrivateFieldGet(this, _Store_temp, "f"));
     }
     clear() {
-        this._temp = this._createTempStorage();
+        __classPrivateFieldSet(this, _Store_temp, __classPrivateFieldGet(this, _Store_instances, "m", _Store_createTempStorage).call(this), "f");
     }
-    _createTempStorage() {
-        return deepClone(this._backUpDefaultStorage);
+    destroy() {
+        __classPrivateFieldSet(this, _Store_temp, null, "f");
+        __classPrivateFieldSet(this, _Store_static, null, "f");
     }
 }
+_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"));
+};

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

@@ -0,0 +1 @@
+export declare function enhanceFontFamliy(fontFamily?: string): string;

package/dist/esm/lib/text.js

@@ -0,0 +1,4 @@
+const baseFontFamilyList = ['-apple-system', '"system-ui"', ' "Segoe UI"', ' Roboto', '"Helvetica Neue"', 'Arial', '"Noto Sans"', ' sans-serif'];
+export function enhanceFontFamliy(fontFamily) {
+    return [fontFamily, ...baseFontFamilyList].join(', ');
+}

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

@@ -2,4 +2,5 @@ type Middleware = (ctx: any, next: Middleware) => any;
 export declare function compose(middleware: Middleware[]): (context: any, next?: Middleware) => any;
 export declare function delay(time: number): Promise<void>;
 export declare function throttle(fn: (...args: any[]) => any, timeout: number): (...args: any[]) => any;
+export declare function debounce(fn: (...args: any[]) => any, timeout: number): (...args: any[]) => any;
 export {};

package/dist/esm/lib/time.js

@@ -27,7 +27,7 @@ export function delay(time) {
 export function throttle(fn, timeout) {
     let timer = -1;
     return function (...args) {
-        if (timer > 0) {
+        if (timer >= 0) {
             return;
         }
         timer = setTimeout(() => {
@@ -36,3 +36,15 @@ export function throttle(fn, timeout) {
         }, timeout);
     };
 }
+export function debounce(fn, timeout) {
+    let timer = -1;
+    return function (...args) {
+        if (timer >= 0) {
+            window.clearTimeout(timer);
+        }
+        timer = setTimeout(() => {
+            fn(...args);
+            timer = -1;
+        }, timeout);
+    };
+}

package/dist/esm/lib/view-box.js

@@ -4,8 +4,10 @@ export function calcViewBoxSize(viewElem, opts) {
     const { viewScaleInfo } = opts;
     const { scale } = viewScaleInfo;
     let { borderRadius } = viewElem.detail;
+    const { borderDash } = viewElem.detail;
+    const hasBorderDash = Array.isArray(borderDash) && borderDash.length > 0;
     const { boxSizing = defaultElemConfig.boxSizing, borderWidth } = viewElem.detail;
-    if (typeof borderWidth !== 'number') {
+    if (Array.isArray(borderWidth)) {
         borderRadius = 0;
     }
     let { x, y, w, h } = viewElem;
@@ -21,7 +23,7 @@ export function calcViewBoxSize(viewElem, opts) {
     if (typeof borderWidth === 'number') {
         bw = (borderWidth || 0) * scale;
     }
-    if (boxSizing === 'border-box') {
+    if (boxSizing === 'border-box' && !hasBorderDash) {
         x = viewElem.x + bw / 2;
         y = viewElem.y + bw / 2;
         w = viewElem.w - bw;