react-design-editor 0.0.37 → 0.0.38

package/lib/handlers/WorkareaHandler.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fabric_1 = require("fabric");
+class WorkareaHandler {
+    constructor(handler) {
+        /**
+         * Set the layout on workarea
+         * @param {WorkareaLayout} layout
+         * @returns
+         */
+        this.setLayout = (layout) => {
+            this.handler.workarea.set('layout', layout);
+            const { _element, isElement, workareaWidth, workareaHeight } = this.handler.workarea;
+            const { canvas } = this.handler;
+            let scaleX = 1;
+            let scaleY = 1;
+            const isFixed = layout === 'fixed';
+            const isResponsive = layout === 'responsive';
+            const isFullscreen = layout === 'fullscreen';
+            if (isElement) {
+                if (isFixed) {
+                    scaleX = workareaWidth / _element.width;
+                    scaleY = workareaHeight / _element.height;
+                }
+                else if (isResponsive) {
+                    const scales = this.calculateScale();
+                    scaleX = scales.scaleX;
+                    scaleY = scales.scaleY;
+                }
+                else {
+                    scaleX = canvas.getWidth() / _element.width;
+                    scaleY = canvas.getHeight() / _element.height;
+                }
+            }
+            this.handler.getObjects().forEach(obj => {
+                const { id, player } = obj;
+                if (id !== 'workarea') {
+                    const objScaleX = !isFullscreen ? 1 : scaleX;
+                    const objScaleY = !isFullscreen ? 1 : scaleY;
+                    const objWidth = obj.width * objScaleX * canvas.getZoom();
+                    const objHeight = obj.height * objScaleY * canvas.getZoom();
+                    const el = this.handler.elementHandler.findById(obj.id);
+                    this.handler.elementHandler.setSize(el, obj);
+                    if (player) {
+                        player.setPlayerSize(objWidth, objHeight);
+                    }
+                    obj.set({
+                        scaleX: !isFullscreen ? 1 : objScaleX,
+                        scaleY: !isFullscreen ? 1 : objScaleY,
+                    });
+                }
+            });
+            if (isResponsive) {
+                const center = canvas.getCenter();
+                if (isElement) {
+                    this.handler.workarea.set({
+                        scaleX: 1,
+                        scaleY: 1,
+                    });
+                    this.handler.zoomHandler.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), scaleX);
+                }
+                else {
+                    this.handler.workarea.set({
+                        width: workareaWidth,
+                        height: workareaHeight,
+                    });
+                    scaleX = canvas.getWidth() / workareaWidth;
+                    scaleY = canvas.getHeight() / workareaHeight;
+                    if (workareaHeight >= workareaWidth) {
+                        scaleX = scaleY;
+                    }
+                    else {
+                        scaleY = scaleX;
+                    }
+                    this.handler.zoomHandler.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), scaleX);
+                }
+                canvas.centerObject(this.handler.workarea);
+                canvas.renderAll();
+                return;
+            }
+            if (isElement) {
+                this.handler.workarea.set({
+                    width: _element.width,
+                    height: _element.height,
+                    scaleX,
+                    scaleY,
+                });
+            }
+            else {
+                const width = isFixed ? workareaWidth : this.handler.canvas.getWidth();
+                const height = isFixed ? workareaHeight : this.handler.canvas.getHeight();
+                this.handler.workarea.set({
+                    width,
+                    height,
+                    backgroundColor: 'rgba(255, 255, 255, 1)',
+                });
+                this.handler.canvas.renderAll();
+                if (isFixed) {
+                    canvas.centerObject(this.handler.workarea);
+                }
+                else {
+                    this.handler.workarea.set({
+                        left: 0,
+                        top: 0,
+                    });
+                }
+            }
+            canvas.centerObject(this.handler.workarea);
+            const center = canvas.getCenter();
+            canvas.setViewportTransform([1, 0, 0, 1, 0, 0]);
+            this.handler.zoomHandler.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), 1);
+            canvas.renderAll();
+        };
+        /**
+         * Set the responsive image on Workarea
+         * @param {string | File} [source]
+         * @param {boolean} [loaded]
+         * @returns
+         */
+        this.setResponsiveImage = async (source, loaded) => {
+            const imageFromUrl = async (src = '') => {
+                return new Promise(resolve => {
+                    fabric_1.fabric.Image.fromURL(src, (img) => {
+                        const { canvas, workarea, editable } = this.handler;
+                        const { workareaWidth, workareaHeight } = workarea;
+                        const { scaleX, scaleY } = this.calculateScale(img);
+                        if (img._element) {
+                            workarea.set({
+                                ...img,
+                                isElement: true,
+                                selectable: false,
+                            });
+                        }
+                        else {
+                            const image = new Image(workareaWidth, workareaHeight);
+                            workarea.setElement(image);
+                            workarea.set({
+                                isElement: false,
+                                selectable: false,
+                                width: workareaWidth,
+                                height: workareaHeight,
+                            });
+                        }
+                        if (editable && !loaded) {
+                            canvas.getObjects().forEach(obj => {
+                                const { id, player } = obj;
+                                if (id !== 'workarea') {
+                                    const objWidth = obj.width * scaleX;
+                                    const objHeight = obj.height * scaleY;
+                                    const el = this.handler.elementHandler.findById(id);
+                                    this.handler.elementHandler.setScaleOrAngle(el, obj);
+                                    this.handler.elementHandler.setSize(el, obj);
+                                    if (player) {
+                                        player.setPlayerSize(objWidth, objHeight);
+                                    }
+                                    obj.set({
+                                        scaleX: 1,
+                                        scaleY: 1,
+                                    });
+                                    obj.setCoords();
+                                }
+                            });
+                        }
+                        // 파일이 없을 경우 Canvas의 nextWidth, nextHeight 값이 변경되기 전 상태에서 zoomToFit이 동작함
+                        // 정상 동작 resize event logic => zoomToFit
+                        // 현재 동작 zoomToFit -> resize event logic
+                        this.handler.zoomHandler.zoomToFit();
+                        canvas.centerObject(workarea);
+                        resolve(workarea);
+                    });
+                });
+            };
+            const { workarea } = this.handler;
+            if (!source) {
+                workarea.set({
+                    src: null,
+                    file: null,
+                });
+                return imageFromUrl(source);
+            }
+            if (source instanceof File) {
+                return new Promise(resolve => {
+                    const reader = new FileReader();
+                    reader.onload = () => {
+                        workarea.set({
+                            file: source,
+                        });
+                        imageFromUrl(reader.result).then(resolve);
+                    };
+                    reader.readAsDataURL(source);
+                });
+            }
+            else {
+                workarea.set({
+                    src: source,
+                });
+                return imageFromUrl(source);
+            }
+        };
+        /**
+         * Set the image on Workarea
+         * @param {string | File} source
+         * @param {boolean} [loaded=false]
+         * @returns
+         */
+        this.setImage = async (source, loaded = false) => {
+            const { canvas, workarea, editable } = this.handler;
+            if (workarea.layout === 'responsive') {
+                return this.setResponsiveImage(source, loaded);
+            }
+            const imageFromUrl = async (src) => {
+                return new Promise(resolve => {
+                    fabric_1.fabric.Image.fromURL(src, (img) => {
+                        let width = canvas.getWidth();
+                        let height = canvas.getHeight();
+                        if (workarea.layout === 'fixed') {
+                            width = workarea.width * workarea.scaleX;
+                            height = workarea.height * workarea.scaleY;
+                        }
+                        let scaleX = 1;
+                        let scaleY = 1;
+                        if (img._element) {
+                            scaleX = width / img.width;
+                            scaleY = height / img.height;
+                            img.set({
+                                originX: 'left',
+                                originY: 'top',
+                                scaleX,
+                                scaleY,
+                            });
+                            workarea.set({
+                                ...img,
+                                isElement: true,
+                                selectable: false,
+                            });
+                        }
+                        else {
+                            workarea.setElement(new Image());
+                            workarea.set({
+                                width,
+                                height,
+                                scaleX,
+                                scaleY,
+                                isElement: false,
+                                selectable: false,
+                            });
+                        }
+                        canvas.centerObject(workarea);
+                        if (editable && !loaded) {
+                            const { layout } = workarea;
+                            canvas.getObjects().forEach(obj => {
+                                const { id, player } = obj;
+                                if (id !== 'workarea') {
+                                    scaleX = layout === 'fullscreen' ? scaleX : obj.scaleX;
+                                    scaleY = layout === 'fullscreen' ? scaleY : obj.scaleY;
+                                    const el = this.handler.elementHandler.findById(id);
+                                    this.handler.elementHandler.setSize(el, obj);
+                                    if (player) {
+                                        const objWidth = obj.width * scaleX;
+                                        const objHeight = obj.height * scaleY;
+                                        player.setPlayerSize(objWidth, objHeight);
+                                    }
+                                    obj.set({
+                                        scaleX,
+                                        scaleY,
+                                    });
+                                    obj.setCoords();
+                                }
+                            });
+                        }
+                        const center = canvas.getCenter();
+                        const zoom = loaded || workarea.layout === 'fullscreen' ? 1 : this.handler.canvas.getZoom();
+                        canvas.setViewportTransform([1, 0, 0, 1, 0, 0]);
+                        this.handler.zoomHandler.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), zoom);
+                        canvas.renderAll();
+                        resolve(workarea);
+                    });
+                });
+            };
+            if (!source) {
+                workarea.set({
+                    src: null,
+                    file: null,
+                });
+                return imageFromUrl(source);
+            }
+            if (source instanceof File) {
+                return new Promise(resolve => {
+                    const reader = new FileReader();
+                    reader.onload = () => {
+                        workarea.set({
+                            file: source,
+                        });
+                        imageFromUrl(reader.result).then(resolve);
+                    };
+                    reader.readAsDataURL(source);
+                });
+            }
+            else {
+                workarea.set({
+                    src: source,
+                });
+                return imageFromUrl(source);
+            }
+        };
+        /**
+         * Calculate scale to the image
+         *
+         * @param {FabricImage} [image]
+         * @returns
+         */
+        this.calculateScale = (image) => {
+            const { canvas, workarea } = this.handler;
+            const { workareaWidth, workareaHeight } = workarea;
+            const { _element } = image || workarea;
+            const width = _element?.width || workareaWidth;
+            const height = _element?.height || workareaHeight;
+            let scaleX = canvas.getWidth() / width;
+            let scaleY = canvas.getHeight() / height;
+            if (height >= width) {
+                scaleX = scaleY;
+                if (canvas.getWidth() < width * scaleX) {
+                    scaleX = scaleX * (canvas.getWidth() / (width * scaleX));
+                }
+            }
+            else {
+                scaleY = scaleX;
+                if (canvas.getHeight() < height * scaleX) {
+                    scaleX = scaleX * (canvas.getHeight() / (height * scaleX));
+                }
+            }
+            return { scaleX, scaleY };
+        };
+        this.handler = handler;
+        this.initialize();
+    }
+    /**
+     * Initialize workarea
+     *
+     * @author salgum1114
+     */
+    initialize() {
+        const { workareaOption } = this.handler;
+        const image = new Image(workareaOption.width, workareaOption.height);
+        image.width = workareaOption.width;
+        image.height = workareaOption.height;
+        this.handler.workarea = new fabric_1.fabric.Image(image, workareaOption);
+        this.handler.canvas.add(this.handler.workarea);
+        this.handler.objects = this.handler.getObjects();
+        this.handler.canvas.centerObject(this.handler.workarea);
+        this.handler.canvas.renderAll();
+    }
+}
+exports.default = WorkareaHandler;

package/lib/handlers/ZoomHandler.d.ts

@@ -0,0 +1,48 @@
+import { fabric } from 'fabric';
+import Handler from './Handler';
+import { FabricObject } from '../utils';
+declare class ZoomHandler {
+    handler?: Handler;
+    constructor(handler: Handler);
+    /**
+     * Zoom to point
+     *
+     * @param {fabric.Point} point
+     * @param {number} zoom ex) 0 ~ 1. Not percentage value.
+     */
+    zoomToPoint: (point: fabric.Point, zoom: number) => void;
+    /**
+     * Zoom one to one
+     *
+     */
+    zoomOneToOne: () => void;
+    /**
+     * Zoom to fit
+     *
+     */
+    zoomToFit: () => void;
+    /**
+     * Zoom in
+     *
+     */
+    zoomIn: () => void;
+    /**
+     * Zoom out
+     *
+     */
+    zoomOut: () => void;
+    /**
+     * Zoom to center with object
+     *
+     * @param {FabricObject} target If zoomFit true, rescaled canvas zoom.
+     */
+    zoomToCenterWithObject: (target: FabricObject, zoomFit?: boolean) => void;
+    /**
+     * Zoom to center with objects
+     *
+     * @param {boolean} [zoomFit] If zoomFit true, rescaled canvas zoom.
+     * @returns
+     */
+    zoomToCenter: (zoomFit?: boolean) => void;
+}
+export default ZoomHandler;

package/lib/handlers/ZoomHandler.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fabric_1 = require("fabric");
+class ZoomHandler {
+    constructor(handler) {
+        /**
+         * Zoom to point
+         *
+         * @param {fabric.Point} point
+         * @param {number} zoom ex) 0 ~ 1. Not percentage value.
+         */
+        this.zoomToPoint = (point, zoom) => {
+            const { minZoom, maxZoom } = this.handler;
+            let zoomRatio = zoom;
+            if (zoom <= minZoom / 100) {
+                zoomRatio = minZoom / 100;
+            }
+            else if (zoom >= maxZoom / 100) {
+                zoomRatio = maxZoom / 100;
+            }
+            this.handler.canvas.zoomToPoint(point, zoomRatio);
+            this.handler.getObjects().forEach(obj => {
+                if (obj.superType === 'element') {
+                    const { id, width, height, player } = obj;
+                    const el = this.handler.elementHandler.findById(id);
+                    // update the element
+                    this.handler.elementHandler.setScaleOrAngle(el, obj);
+                    this.handler.elementHandler.setSize(el, obj);
+                    this.handler.elementHandler.setPosition(el, obj);
+                    if (player) {
+                        player.setPlayerSize(width, height);
+                    }
+                }
+            });
+            if (this.handler.onZoom) {
+                this.handler.onZoom(zoomRatio);
+            }
+            this.handler.canvas.requestRenderAll();
+        };
+        /**
+         * Zoom one to one
+         *
+         */
+        this.zoomOneToOne = () => {
+            const center = this.handler.canvas.getCenter();
+            this.handler.canvas.setViewportTransform([1, 0, 0, 1, 0, 0]);
+            this.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), 1);
+        };
+        /**
+         * Zoom to fit
+         *
+         */
+        this.zoomToFit = () => {
+            let scaleX = this.handler.canvas.getWidth() / this.handler.workarea.width;
+            const scaleY = this.handler.canvas.getHeight() / this.handler.workarea.height;
+            if (this.handler.workarea.height >= this.handler.workarea.width) {
+                scaleX = scaleY;
+                if (this.handler.canvas.getWidth() < this.handler.workarea.width * scaleX) {
+                    scaleX = scaleX * (this.handler.canvas.getWidth() / (this.handler.workarea.width * scaleX));
+                }
+            }
+            else {
+                if (this.handler.canvas.getHeight() < this.handler.workarea.height * scaleX) {
+                    scaleX = scaleX * (this.handler.canvas.getHeight() / (this.handler.workarea.height * scaleX));
+                }
+            }
+            const center = this.handler.canvas.getCenter();
+            this.handler.canvas.setViewportTransform([1, 0, 0, 1, 0, 0]);
+            this.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), scaleX);
+        };
+        /**
+         * Zoom in
+         *
+         */
+        this.zoomIn = () => {
+            let zoomRatio = this.handler.canvas.getZoom();
+            zoomRatio += 0.05;
+            const center = this.handler.canvas.getCenter();
+            this.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), zoomRatio);
+        };
+        /**
+         * Zoom out
+         *
+         */
+        this.zoomOut = () => {
+            let zoomRatio = this.handler.canvas.getZoom();
+            zoomRatio -= 0.05;
+            const center = this.handler.canvas.getCenter();
+            this.zoomToPoint(new fabric_1.fabric.Point(center.left, center.top), zoomRatio);
+        };
+        /**
+         * Zoom to center with object
+         *
+         * @param {FabricObject} target If zoomFit true, rescaled canvas zoom.
+         */
+        this.zoomToCenterWithObject = (target, zoomFit) => {
+            const { left: canvasLeft, top: canvasTop } = this.handler.canvas.getCenter();
+            const { left, top, width, height } = target;
+            const diffTop = canvasTop - (top + height / 2);
+            const diffLeft = canvasLeft - (left + width / 2);
+            if (zoomFit) {
+                let scaleX;
+                let scaleY;
+                scaleX = this.handler.canvas.getWidth() / width;
+                scaleY = this.handler.canvas.getHeight() / height;
+                if (height > width) {
+                    scaleX = scaleY;
+                    if (this.handler.canvas.getWidth() < width * scaleX) {
+                        scaleX = scaleX * (this.handler.canvas.getWidth() / (width * scaleX));
+                    }
+                }
+                else {
+                    scaleY = scaleX;
+                    if (this.handler.canvas.getHeight() < height * scaleX) {
+                        scaleX = scaleX * (this.handler.canvas.getHeight() / (height * scaleX));
+                    }
+                }
+                this.handler.canvas.setViewportTransform([1, 0, 0, 1, diffLeft, diffTop]);
+                this.zoomToPoint(new fabric_1.fabric.Point(canvasLeft, canvasTop), scaleX);
+            }
+            else {
+                const zoom = this.handler.canvas.getZoom();
+                this.handler.canvas.setViewportTransform([1, 0, 0, 1, diffLeft, diffTop]);
+                this.zoomToPoint(new fabric_1.fabric.Point(canvasLeft, canvasTop), zoom);
+            }
+        };
+        /**
+         * Zoom to center with objects
+         *
+         * @param {boolean} [zoomFit] If zoomFit true, rescaled canvas zoom.
+         * @returns
+         */
+        this.zoomToCenter = (zoomFit) => {
+            const activeObject = this.handler.canvas.getActiveObject();
+            if (!activeObject) {
+                return;
+            }
+            this.zoomToCenterWithObject(activeObject, zoomFit);
+        };
+        this.handler = handler;
+    }
+}
+exports.default = ZoomHandler;

package/lib/handlers/index.d.ts

@@ -0,0 +1,23 @@
+export { default as Handler } from './Handler';
+export { default as ImageHandler } from './ImageHandler';
+export { default as ChartHandler } from './ChartHandler';
+export { default as ElementHandler } from './ElementHandler';
+export { default as CropHandler } from './CropHandler';
+export { default as AnimationHandler } from './AnimationHandler';
+export { default as ContextmenuHandler } from './ContextmenuHandler';
+export { default as TooltipHandler } from './TooltipHandler';
+export { default as TransactionHandler } from './TransactionHandler';
+export { default as ZoomHandler } from './ZoomHandler';
+export { default as WorkareaHandler } from './WorkareaHandler';
+export { default as InteractionHandler } from './InteractionHandler';
+export { default as GridHandler } from './GridHandler';
+export { default as PortHandler } from './PortHandler';
+export { default as LinkHandler } from './LinkHandler';
+export { default as NodeHandler } from './NodeHandler';
+export { default as AlignmentHandler } from './AlignmentHandler';
+export { default as GuidelineHandler } from './GuidelineHandler';
+export { default as EventHandler } from './EventHandler';
+export { default as DrawingHandler } from './DrawingHandler';
+export { default as ShortcutHandler } from './ShortcutHandler';
+export { default as FiberHandler } from './FiberHandler';
+export { default as CustomHandler } from './CustomHandler';

package/lib/handlers/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Handler_1 = require("./Handler");
+Object.defineProperty(exports, "Handler", { enumerable: true, get: function () { return Handler_1.default; } });
+var ImageHandler_1 = require("./ImageHandler");
+Object.defineProperty(exports, "ImageHandler", { enumerable: true, get: function () { return ImageHandler_1.default; } });
+var ChartHandler_1 = require("./ChartHandler");
+Object.defineProperty(exports, "ChartHandler", { enumerable: true, get: function () { return ChartHandler_1.default; } });
+var ElementHandler_1 = require("./ElementHandler");
+Object.defineProperty(exports, "ElementHandler", { enumerable: true, get: function () { return ElementHandler_1.default; } });
+var CropHandler_1 = require("./CropHandler");
+Object.defineProperty(exports, "CropHandler", { enumerable: true, get: function () { return CropHandler_1.default; } });
+var AnimationHandler_1 = require("./AnimationHandler");
+Object.defineProperty(exports, "AnimationHandler", { enumerable: true, get: function () { return AnimationHandler_1.default; } });
+var ContextmenuHandler_1 = require("./ContextmenuHandler");
+Object.defineProperty(exports, "ContextmenuHandler", { enumerable: true, get: function () { return ContextmenuHandler_1.default; } });
+var TooltipHandler_1 = require("./TooltipHandler");
+Object.defineProperty(exports, "TooltipHandler", { enumerable: true, get: function () { return TooltipHandler_1.default; } });
+var TransactionHandler_1 = require("./TransactionHandler");
+Object.defineProperty(exports, "TransactionHandler", { enumerable: true, get: function () { return TransactionHandler_1.default; } });
+var ZoomHandler_1 = require("./ZoomHandler");
+Object.defineProperty(exports, "ZoomHandler", { enumerable: true, get: function () { return ZoomHandler_1.default; } });
+var WorkareaHandler_1 = require("./WorkareaHandler");
+Object.defineProperty(exports, "WorkareaHandler", { enumerable: true, get: function () { return WorkareaHandler_1.default; } });
+var InteractionHandler_1 = require("./InteractionHandler");
+Object.defineProperty(exports, "InteractionHandler", { enumerable: true, get: function () { return InteractionHandler_1.default; } });
+var GridHandler_1 = require("./GridHandler");
+Object.defineProperty(exports, "GridHandler", { enumerable: true, get: function () { return GridHandler_1.default; } });
+var PortHandler_1 = require("./PortHandler");
+Object.defineProperty(exports, "PortHandler", { enumerable: true, get: function () { return PortHandler_1.default; } });
+var LinkHandler_1 = require("./LinkHandler");
+Object.defineProperty(exports, "LinkHandler", { enumerable: true, get: function () { return LinkHandler_1.default; } });
+var NodeHandler_1 = require("./NodeHandler");
+Object.defineProperty(exports, "NodeHandler", { enumerable: true, get: function () { return NodeHandler_1.default; } });
+var AlignmentHandler_1 = require("./AlignmentHandler");
+Object.defineProperty(exports, "AlignmentHandler", { enumerable: true, get: function () { return AlignmentHandler_1.default; } });
+var GuidelineHandler_1 = require("./GuidelineHandler");
+Object.defineProperty(exports, "GuidelineHandler", { enumerable: true, get: function () { return GuidelineHandler_1.default; } });
+var EventHandler_1 = require("./EventHandler");
+Object.defineProperty(exports, "EventHandler", { enumerable: true, get: function () { return EventHandler_1.default; } });
+var DrawingHandler_1 = require("./DrawingHandler");
+Object.defineProperty(exports, "DrawingHandler", { enumerable: true, get: function () { return DrawingHandler_1.default; } });
+var ShortcutHandler_1 = require("./ShortcutHandler");
+Object.defineProperty(exports, "ShortcutHandler", { enumerable: true, get: function () { return ShortcutHandler_1.default; } });
+var FiberHandler_1 = require("./FiberHandler");
+Object.defineProperty(exports, "FiberHandler", { enumerable: true, get: function () { return FiberHandler_1.default; } });
+var CustomHandler_1 = require("./CustomHandler");
+Object.defineProperty(exports, "CustomHandler", { enumerable: true, get: function () { return CustomHandler_1.default; } });

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Canvas';
+export { default as Canvas } from './Canvas';
+export { default as CanvasObject } from './CanvasObject';
+export * from './handlers';
+export * from './objects';
+export * from './utils';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Canvas"), exports);
+var Canvas_1 = require("./Canvas");
+Object.defineProperty(exports, "Canvas", { enumerable: true, get: function () { return Canvas_1.default; } });
+var CanvasObject_1 = require("./CanvasObject");
+Object.defineProperty(exports, "CanvasObject", { enumerable: true, get: function () { return CanvasObject_1.default; } });
+__exportStar(require("./handlers"), exports);
+__exportStar(require("./objects"), exports);
+__exportStar(require("./utils"), exports);

package/lib/objects/Arrow.d.ts

@@ -0,0 +1,2 @@
+declare const Arrow: any;
+export default Arrow;