plotboilerplate 1.28.0 → 1.28.1

package/src/_esm/utils/helpers/BezierPathInteractionHelper.js

@@ -1,655 +0,0 @@
-"use strict";
-/**
- * Interfaces and class for automatically handling Bézier curves.
- *
- * @requires AlloyFinger
- * @requires BezierPath
- * @requires CubicBezierPath
- * @requires KeyHandler
- * @requires MouseHandler
- * @requires PlotBoilerplate
- * @requires VertEvent
- * @requires Vertex
- * @requires XMouseEvent
- * @requires XYCoords
- *
- *
- * @author   Ikaros Kappler
- * @date     2020-07-31
- * @modified 2020-08-03 Ported this class from vanilla JS to Typescript.
- * @modified 2020-08-12 Added a distance check before handling the click/tap event.
- * @modified 2021-01-03 Changed property to `autoAdjustPaths` in the HandlerOptions interface (typo).
- * @modified 2021-01-03 Added following new functions: `addPathVertexDragStartListeners`, `removePathVertexDragStartListeners`, `addPathVertexDragEndListeners` and `removePathVertexDragEndListeners`.
- * @modified 2021-03-31 Fixed the issue with the new AlloyFinger (Typescript).
- * @modified 2022-02-03 Changing the element to catch events (eventCatcher instead of canvas).
- * @modified 2024-03-10 Fixing some types for Typescript 5 compatibility.
- * @modified 2025-04-14 Added the `BezierPathInteractionHelper.drawHandleLines` method.
- * @modified 2025-04-14 Fixing correct event types for touch events in `BezierPathInteractionHelper`.
- * @modified 2025-04-14 BezierPathInteractionHelper: Changed default value of `HelperOptions.autoAdjustPaths` from `true` to `false`.
- * @modified 2025-05-05 Added optional params `draw` and `fill` to BezierPathInteractionHelper.drawHandleLines` method.
- * @modified 2025-05-05 Class `BezierPathInteractionHelper` now implementing `IShapeInteractionHelper`.
- * @modified 2025-05-07 Tweaking performance of `BezierPathInteractionHelper`: only triggering redraw now when mouse move within given detect range.
- * @version  1.2.1
- *
- * @file BezierPathInteractionHelper
- * @public
- **/
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BezierPathInteractionHelper = void 0;
-// I would like to use AlloyFinger from the node_modules, but it seems
-// AlloyTeam has forgotten to publish their d.ts file.
-const alloyfinger_typescript_1 = __importDefault(require("alloyfinger-typescript"));
-const BezierPath_1 = require("../../BezierPath");
-const KeyHandler_1 = require("../../KeyHandler");
-const MouseHandler_1 = require("../../MouseHandler");
-const PlotBoilerplate_1 = require("../../PlotBoilerplate");
-const Vertex_1 = require("../../Vertex");
-/**
- * @classdesc A helper for adding vertices to and remove vertices from Bézier paths.
- * By default the 'delete' key is used to remove vertices or paths.
- *
- * For convenience this helper is capable of handling multiple paths which are kept
- * in an array.
- *
- * [Demo](https://www.plotboilerplate.io/repo/demos/23-bezier-point-distance/ "Demo")
- *
- * @public
- **/
-class BezierPathInteractionHelper {
-    /**
-     * Pre: all paths must have been added to the PlotBoilerplate's drawable buffer (use the add(Drawable) function).
-     *
-     * The move callback accepts four params:
-     *   * The point on the closest curve (Vertex)
-     *   * The mouse or touch position (Vertex)
-     *   * The curve position (float t)
-     *   * The curve index on the array (integer)
-     *
-     *
-     * @constructor
-     * @name BezierPathInteractionHelper
-     * @param {PlotBoilerplate} pb
-     * @param {Array<BezierPath>} paths
-     * @param {boolean} options.autoAdjustPaths - If true then inner path points will be auto-adjusted to keep the curve smooth.
-     * @param {boolean} options.allowPathRemoval - If true then full paths can be removed (by removing selected vertices).
-     * @param {number} maxDetectDistance - The max detection distance. No events will be fired if the mouse/touch pointer is outside this range (default is Number.MAX_VALUE).
-     * @param {function(number,Vertex,Vertex,number)} options.onPointerMoved (pathIndex,pathPoint,pointer,t)
-     * @param {function(number,number,BezierPath,BezierPath)} options.onVertexInserted (pathIndex,insertIndex,newPath,oldPath)
-     * @param {function(number,number[],BezierPath,BezierPath)} options.onVerticesDeleted (pathIndex,removedVertexIndices,newPath,oldPath)
-     * @param {function(number,BezierPath)} options.onPathRemoved (pathIndex,oldPath)
-     **/
-    constructor(pb, paths, options) {
-        options = options || {};
-        this.pb = pb;
-        this.paths = [];
-        this.onPointerMoved =
-            typeof options.onPointerMoved === "function"
-                ? options.onPointerMoved
-                : (i, a, b, t) => { };
-        this.onVertexInserted =
-            typeof options.onVertexInserted === "function"
-                ? options.onVertexInserted
-                : (i, j, n, o) => { };
-        this.onVerticesDeleted =
-            typeof options.onVerticesDeleted === "function"
-                ? options.onVerticesDeleted
-                : (i, r, n, o) => { };
-        this.onPathRemoved = typeof options.onPathRemoved === "function" ? options.onPathRemoved : (i, o) => { };
-        this.autoAdjustPaths = typeof options.autoAdjustPaths === "boolean" ? options.autoAdjustPaths : false; // true;
-        this.allowPathRemoval = typeof options.allowPathRemoval === "boolean" ? options.allowPathRemoval : true;
-        this.maxDetectDistance = typeof options.maxDetectDistance === "number" ? options.maxDetectDistance : Number.MAX_VALUE;
-        this.mouseIsOver = false;
-        this.currentPathIndex = -1;
-        this.currentDistance = Number.MAX_VALUE;
-        this.currentT = 0.0;
-        this.currentA = new Vertex_1.Vertex(0, 0); // Position on the curve
-        this.currentB = new Vertex_1.Vertex(0, 0); // Mouse/Touch position
-        // Rebuild the array to avoid outside manipulations.
-        for (var i = 0; i < paths.length; i++) {
-            this.addPath(paths[i]);
-        }
-        this._mouseEnterListener = () => {
-            this.mouseIsOver = true;
-        };
-        this._mouseLeaveListener = () => {
-            this.mouseIsOver = false;
-            this._clearMoveEvent();
-        };
-        this._mouseHandler = this._installMouseListener();
-        this._touchHandler = this._installTouchListener();
-        this._keyHandler = this._installKeyListener();
-        // Paths might have changed by auto-adjustment.
-        if (this.autoAdjustPaths) {
-            pb.redraw();
-        }
-    }
-    /**
-     * Manually add a path to this helper.
-     * Note that if `autoAdjustPaths==true` then listeners will be installed to the path's vertices to
-     * keep the path smooth at all times.
-     *
-     * @method addPath
-     * @instance
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The path to add.
-     * @return {boolean} Duplicate path instances cannot be added; function will return false if path already exists.
-     **/
-    addPath(path) {
-        const pathIndex = this._locatePath(path);
-        if (pathIndex != -1)
-            return false;
-        this.paths.push(path);
-        if (this.autoAdjustPaths)
-            BezierPathInteractionHelper.setPathAutoAdjust(path);
-        return true;
-    }
-    /**
-     * Manually remove a path from this helper.
-     * Note that this method ignores the `allowPathRemoval` option.
-     *
-     * @method removePath
-     * @instance
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The path to remove.
-     * @return {boolean} Returns false if the path could not be found.
-     **/
-    removePath(path) {
-        const pathIndex = this._locatePath(path);
-        if (pathIndex == -1)
-            return false;
-        this.removePathAt(pathIndex);
-        return true;
-    }
-    /**
-     * Remove the path at the given index.
-     *
-     * @method removePathAt
-     * @instance
-     * @memberof BezierPathInteractionHelper
-     * @param {number} pathIndex - The index of the path (must be inside bounds, see `this.paths` array).
-     * @return {void}
-     **/
-    removePathAt(pathIndex) {
-        const path = this.paths[pathIndex];
-        this.paths = this.paths.filter((value, index) => index != pathIndex);
-        this._removeDefaultPathListeners(path);
-        this.pb.remove(path, false, true); // Remove with vertices
-        this.onPathRemoved(pathIndex, path);
-    }
-    /**
-     * Update the inner status by running the distance calculation again with the current settings.
-     *
-     * Call this if any of the properties changed (like maxDetecDistance).
-     *
-     * @method update
-     * @instance
-     * @memberof BezierPathInteractionHelper
-     * @return {void}
-     **/
-    update() {
-        // Just re-run the calculation with the recent mouse/touch position
-        this._handleMoveEvent(this.currentB.x, this.currentB.y);
-    }
-    /**
-     * Draw grey handle lines.
-     *
-     * @param {DrawLib<any>} draw - (optional) The draw library to use. If not provided then `pb.draw` will be used.
-     * @param {DrawLib<any>} fill - (optional) The fill library to use. If not provided then `pb.fill` will be used.
-     */
-    drawHandleLines(draw, fill) {
-        draw = draw || this.pb.draw;
-        fill = fill || this.pb.fill;
-        this.paths.forEach((path) => {
-            path.bezierCurves.forEach((curve) => {
-                this.pb.draw.line(curve.startPoint, curve.startControlPoint, "rgba(64,192,128,0.333)", 1.0, {
-                    dashOffset: 0.0,
-                    dashArray: [4, 2]
-                });
-                this.pb.draw.line(curve.endPoint, curve.endControlPoint, "rgba(64,192,128,0.333)", 1.0, {
-                    dashOffset: 0.0,
-                    dashArray: [4, 2]
-                });
-            });
-        });
-    }
-    /**
-     * This function should invalidate any installed listeners and invalidate this object.
-     * After calling this function the object might not hold valid data any more and
-     * should not be used any more.
-     *
-     * @method destroy
-     * @instance
-     * @memberof BezierPathInteractionHelper
-     * @return {void}
-     **/
-    destroy() {
-        for (var i = 0; i < this.paths.length; i++) {
-            this._removeDefaultPathListeners(this.paths[i]);
-            // removePathVertexDragStartListeners(this.paths[i], listener);
-        }
-        this.paths = [];
-        this.pb.eventCatcher.removeEventListener("mouseenter", this._mouseEnterListener);
-        this.pb.eventCatcher.removeEventListener("mouseleave", this._mouseLeaveListener);
-        this._mouseHandler.destroy();
-        this._keyHandler.destroy();
-    }
-    // +---------------------------------------------------------------------------------
-    // | A helper function to locate a given path instance inside the array.
-    // |
-    // | @return The index of the path or -1 if not found.
-    // +-------------------------------
-    _locatePath(path) {
-        for (var i = 0; i < this.paths.length; i++) {
-            if (this.paths[i] == path)
-                return i;
-        }
-        return -1;
-    }
-    // +---------------------------------------------------------------------------------
-    // | Handle deletion of any selecte vertex and/or paths.
-    // | Note that this function will trigger a `redraw`.
-    // +-------------------------------
-    _handleDelete() {
-        const pathDeleteIndices = this._handleSingleVertexDelete();
-        // Remove enqueued paths
-        if (this.allowPathRemoval) {
-            // Remove paths starting with the last (!) index.
-            for (var i = pathDeleteIndices.length - 1; i >= 0; i--) {
-                this.removePathAt(pathDeleteIndices[i]);
-            }
-        }
-        this.pb.redraw();
-    }
-    // +---------------------------------------------------------------------------------
-    // | This function removes all selected vertices on the paths without deleting
-    // | full paths (at least two path vertices remaining).
-    // |
-    // | Returned (sorted) array contains indices of those paths that should
-    // | be deleted completely.
-    // +-------------------------------
-    _handleSingleVertexDelete() {
-        // Check all path points (on all paths) for deletion.
-        // Note: whole paths are not meant to be removed this way.
-        //       Keep track of their indices (ascending order) for later removal.
-        const pathDeleteIndices = [];
-        for (var p = 0; p < this.paths.length; p++) {
-            const allVerticesSelected = this._handleDeleteOnPath(p);
-            if (allVerticesSelected)
-                pathDeleteIndices.push(p);
-        }
-        return pathDeleteIndices;
-    }
-    // +---------------------------------------------------------------------------------
-    // | This function removes all selected vertices on the given path (index)
-    // | without deleting the full path (at least two path vertices remaining).
-    // |
-    // | Returns true if path should be fully removed, false otherwise.
-    // +-------------------------------
-    _handleDeleteOnPath(pathIndex) {
-        const path = this.paths[pathIndex];
-        const newCurves = [];
-        const deletedVertIndices = [];
-        // Find first non-selected path point
-        let curveIndex = 0;
-        while (curveIndex < path.bezierCurves.length && path.bezierCurves[curveIndex].startPoint.attr.isSelected) {
-            deletedVertIndices.push(curveIndex), curveIndex++;
-        }
-        // All points selected? Enqueue for deletion.
-        if (curveIndex == path.bezierCurves.length) {
-            // Indicate: path removal required.
-            return true;
-        }
-        // Only keep those curves that have no selected path point (=delete selected)
-        let curStart = path.bezierCurves[curveIndex].startPoint;
-        let curStartControl = path.bezierCurves[curveIndex].startControlPoint;
-        for (var i = curveIndex; i < path.bezierCurves.length; i++) {
-            if (!path.bezierCurves[i].endPoint.attr.isSelected) {
-                newCurves.push([
-                    curStart.clone(),
-                    path.bezierCurves[i].endPoint.clone(),
-                    curStartControl.clone(),
-                    path.bezierCurves[i].endControlPoint.clone()
-                ]);
-                if (i + 1 < path.bezierCurves.length) {
-                    curStart = path.bezierCurves[i].endPoint;
-                    curStartControl = path.bezierCurves[i + 1].startControlPoint;
-                }
-            }
-            else {
-                // TODO: remove drag listener from removed vertex!
-                deletedVertIndices.push(i);
-            }
-        }
-        // Do not remove the whole path.
-        // Do not replace the path if no vertices were deleted.
-        if (newCurves.length != 0 && newCurves.length != path.bezierCurves.length) {
-            const newPath = BezierPath_1.BezierPath.fromArray(newCurves);
-            const oldPath = this.paths[pathIndex];
-            this._replacePathAt(pathIndex, newPath);
-            this.onVerticesDeleted(pathIndex, deletedVertIndices, newPath, oldPath);
-            // Indicate: no path removal required
-            return false;
-        }
-        else {
-            // Indicate full path removal if no curve would be left.
-            return newCurves.length == 0;
-        }
-    }
-    // +---------------------------------------------------------------------------------
-    // | This function replaces a path at the given index with a new one (after change
-    // | of vertex count).
-    // +-------------------------------
-    _replacePathAt(pathIndex, newPath) {
-        const oldPath = this.paths[pathIndex];
-        this.pb.remove(oldPath, false, true); // Remove with vertices
-        oldPath.destroy();
-        this._removeDefaultPathListeners(oldPath);
-        BezierPathInteractionHelper.setPathAutoAdjust(newPath);
-        this.paths[pathIndex] = newPath;
-        this.pb.add(newPath);
-    }
-    // +---------------------------------------------------------------------------------
-    // | Touch and mouse events should call this fuction when the pointer was moved.
-    // +-------------------------------
-    _handleMoveEvent(posX, posY) {
-        const oldA = this.currentA.clone();
-        const oldB = this.currentB.clone();
-        const oldDistance = this.currentDistance;
-        const point = this.pb.transformMousePosition(posX, posY);
-        this.currentB.set(point);
-        this._updateMinDistance();
-        // Always fire even if nothing visually changed?
-        if (this.currentDistance <= this.maxDetectDistance && this.mouseIsOver && this.pb.getDraggedElementCount() == 0) {
-            this.onPointerMoved(this.currentPathIndex, this.currentA, this.currentB, this.currentT);
-        }
-        else {
-            this.onPointerMoved(-1, null, null, 0.0);
-        }
-        // Only redraw when moving inside the detection distance
-        if ((this.currentDistance <= this.maxDetectDistance ||
-            (this.currentDistance > this.maxDetectDistance && oldDistance <= this.maxDetectDistance)) &&
-            (!oldA.equals(this.currentA) || !oldB.equals(this.currentB))) {
-            this.pb.redraw();
-        }
-    }
-    // +---------------------------------------------------------------------------------
-    // | This is called when the mouse pointer leaves the canvas or
-    // | when the touch progress ends.
-    // +-------------------------------
-    _clearMoveEvent() {
-        this.onPointerMoved(-1, null, null, 0.0);
-        this.pb.redraw();
-    }
-    // +---------------------------------------------------------------------------------
-    // | Called once upon initialization.
-    // +-------------------------------
-    _installTouchListener() {
-        var _self = this;
-        const afProps = {
-            touchStart: function (_event) {
-                _self.mouseIsOver = true;
-            },
-            touchMove: function (event) {
-                if (_self.pb.getDraggedElementCount() == 0 && event.touches.length > 0) {
-                    _self._handleMoveEvent(event.touches[0].clientX, event.touches[0].clientY);
-                }
-            },
-            touchEnd: function (_event) {
-                _self.mouseIsOver = false;
-                _self._clearMoveEvent();
-            }
-        };
-        if (window["createAlloyFinger"]) {
-            return window["createAlloyFinger"](this.pb.eventCatcher ? this.pb.eventCatcher : this.pb.eventCatcher, afProps);
-        }
-        else {
-            return new alloyfinger_typescript_1.default(this.pb.eventCatcher ? this.pb.eventCatcher : this.pb.eventCatcher, afProps);
-        }
-    }
-    // +---------------------------------------------------------------------------------
-    // | Called once upon initialization.
-    // +-------------------------------
-    _installMouseListener() {
-        var _self = this;
-        var mouseHandler = new MouseHandler_1.MouseHandler(this.pb.eventCatcher)
-            .up(function (e) {
-            if (e.params.wasDragged)
-                return;
-            if (_self._keyHandler.isDown("shift"))
-                return;
-            if (_self.currentDistance > _self.maxDetectDistance || !_self.mouseIsOver)
-                return;
-            const path = _self.paths[_self.currentPathIndex];
-            const vertex = _self.pb.getVertexNear(e.params.pos, PlotBoilerplate_1.PlotBoilerplate.DEFAULT_CLICK_TOLERANCE);
-            if (vertex)
-                return;
-            // Check if there is already a path point at the given split position
-            const pathPoint = path.getPointAt(_self.currentT);
-            const pointNear = _self.pb.getVertexNear(_self.pb.revertMousePosition(pathPoint.x, pathPoint.y), 6.0);
-            if (pointNear) {
-                for (var i = 0; i < path.bezierCurves.length; i++) {
-                    if (path.bezierCurves[i].startPoint.distance(pointNear) <= 6.0 ||
-                        path.bezierCurves[i].endPoint.distance(pointNear) <= 6.0) {
-                        // console.log("There is already a path point near this position.");
-                        return;
-                    }
-                }
-            }
-            //console.log('Inserting vertex at', _self.currentT );
-            const leftPath = path.getSubPathAt(0.0, _self.currentT);
-            const rightPath = path.getSubPathAt(_self.currentT, 1.0);
-            const newCurves = [];
-            for (var i = 0; i < leftPath.bezierCurves.length; i++) {
-                newCurves.push(leftPath.bezierCurves[i]);
-            }
-            for (var i = 0; i < rightPath.bezierCurves.length; i++) {
-                newCurves.push(rightPath.bezierCurves[i]);
-            }
-            const newPath = BezierPath_1.BezierPath.fromArray(newCurves);
-            const oldPath = _self.paths[_self.currentPathIndex];
-            _self._replacePathAt(_self.currentPathIndex, newPath);
-            _self.onVertexInserted(_self.currentPathIndex, leftPath.bezierCurves.length, newPath, oldPath);
-        })
-            .move(function (e) {
-            _self.mouseIsOver = true;
-            _self._handleMoveEvent(e.params.pos.x, e.params.pos.y);
-        });
-        this.pb.eventCatcher.addEventListener("mouseenter", this._mouseEnterListener);
-        this.pb.eventCatcher.addEventListener("mouseleave", this._mouseLeaveListener);
-        return mouseHandler;
-    }
-    // +---------------------------------------------------------------------------------
-    // | Called once upon initialization.
-    // |
-    // | @return {KeyHandler}
-    // +-------------------------------
-    _installKeyListener() {
-        var _self = this;
-        return new KeyHandler_1.KeyHandler({ trackAll: true }).down("delete", function () {
-            _self._handleDelete();
-        });
-    }
-    // +---------------------------------------------------------------------------------
-    // | Removes vertex listeners from all path points.
-    // |
-    // | @param {BezierPath} path - The path to remove vertex listeners from.
-    // +-------------------------------
-    _removeDefaultPathListeners(path) {
-        BezierPathInteractionHelper.removePathVertexDragListeners(path, this._updateMinDistance);
-    }
-    // +---------------------------------------------------------------------------------
-    // | Update the min distance from point `line.b` to the curve. And redraw.
-    // +-------------------------------
-    _updateMinDistance() {
-        if (this.paths.length == 0) {
-            return;
-        }
-        let pathIndex = -1;
-        let minDist = Number.MAX_VALUE;
-        let closestPoint = null;
-        let closestT = 0.0;
-        for (var i = 0; i < this.paths.length; i++) {
-            let path = this.paths[i];
-            let t = path.getClosestT(this.currentB);
-            let point = path.getPointAt(t);
-            let dist = point.distance(this.currentB);
-            if (dist < minDist) {
-                pathIndex = i;
-                minDist = dist;
-                closestT = t;
-                closestPoint = point;
-            }
-        }
-        this.currentT = closestT;
-        this.currentPathIndex = pathIndex;
-        this.currentDistance = minDist;
-        closestPoint && this.currentA.set(closestPoint);
-    }
-    // +---------------------------------------------------------------------------------
-    // | Sets all vertices on the given path to `bezierAutoAdjust=true`.
-    // |
-    // | @static
-    // +-------------------------------
-    static setPathAutoAdjust(path) {
-        for (var i = 0; i < path.bezierCurves.length; i++) {
-            const curve = path.bezierCurves[i];
-            path.adjustPredecessorControlPoint(i, true, // obtainHandleLength
-            false // updateArcLength  (we will do this after the loop)
-            );
-            if (i > 0 || path.adjustCircular)
-                curve.startPoint.attr.bezierAutoAdjust = true;
-        }
-        path.updateArcLengths();
-    }
-    /**
-     * A helper function to add drag-start listeners to all vertices of the given path.
-     *
-     * @static
-     * @method addPathVertexDragStartListeners
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The Bézier path to add vertex listeners to.
-     * @param {function} vertexDragStartListener - The drag listeners to add to each path vertex.
-     * @return void
-     **/
-    static addPathVertexDragStartListeners(path, vertexDragStartListener) {
-        for (var i = 0; i < path.bezierCurves.length; i++) {
-            const curve = path.bezierCurves[i];
-            curve.startPoint.listeners.addDragStartListener(vertexDragStartListener);
-            curve.startControlPoint.listeners.addDragStartListener(vertexDragStartListener);
-            curve.endControlPoint.listeners.addDragStartListener(vertexDragStartListener);
-            if (i + 1 == path.bezierCurves.length && !path.adjustCircular)
-                curve.endPoint.listeners.addDragStartListener(vertexDragStartListener);
-            // if( i+1 == path.bezierCurves.length && !path.adjustCircular )
-            // BezierPathIntractionHelper._addVertsDragListener( [curve.startPoint, curve.startControlPoint, curve.endPoint, curve.endControlPoint ], vertexDragListener );
-        }
-    }
-    /**
-     * A helper function to remove drag-start listeners to all vertices of the given path.
-     *
-     * @static
-     * @method removePathVertexDragStartListeners
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The Bézier path to remove vertex listeners from.
-     * @param {function} vertexDragListener - The drag listeners to remove from each path vertex.
-     * @return void
-     **/
-    static removePathVertexDragStartListeners(path, vertexDragStartListener) {
-        for (var i = 0; i < path.bezierCurves.length; i++) {
-            const curve = path.bezierCurves[i];
-            curve.startPoint.listeners.removeDragStartListener(vertexDragStartListener);
-            curve.startControlPoint.listeners.removeDragStartListener(vertexDragStartListener);
-            curve.endControlPoint.listeners.removeDragStartListener(vertexDragStartListener);
-            if (i + 1 == path.bezierCurves.length && !path.adjustCircular)
-                curve.endPoint.listeners.removeDragStartListener(vertexDragStartListener);
-        }
-    }
-    /**
-     * A helper function to add drag listeners to all vertices of the given path.
-     *
-     * @static
-     * @method addPathVertexDragListeners
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The Bézier path to add vertex listeners to.
-     * @param {function} vertexDragListener - The drag listeners to add to each path vertex.
-     * @return void
-     **/
-    static addPathVertexDragListeners(path, vertexDragListener) {
-        for (var i = 0; i < path.bezierCurves.length; i++) {
-            const curve = path.bezierCurves[i];
-            curve.startPoint.listeners.addDragListener(vertexDragListener);
-            curve.startControlPoint.listeners.addDragListener(vertexDragListener);
-            curve.endControlPoint.listeners.addDragListener(vertexDragListener);
-            if (i + 1 == path.bezierCurves.length && !path.adjustCircular)
-                curve.endPoint.listeners.addDragListener(vertexDragListener);
-            // if( i+1 == path.bezierCurves.length && !path.adjustCircular )
-            // BezierPathIntractionHelper._addVertsDragListener( [curve.startPoint, curve.startControlPoint, curve.endPoint, curve.endControlPoint ], vertexDragListener );
-        }
-    }
-    /**
-     * A helper function to remove drag listeners to all vertices of the given path.
-     *
-     * @static
-     * @method removePathVertexDragListeners
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The Bézier path to remove vertex listeners from.
-     * @param {function} vertexDragListener - The drag listeners to remove from each path vertex.
-     * @return void
-     **/
-    static removePathVertexDragListeners(path, vertexDragListener) {
-        for (var i = 0; i < path.bezierCurves.length; i++) {
-            const curve = path.bezierCurves[i];
-            curve.startPoint.listeners.removeDragListener(vertexDragListener);
-            curve.startControlPoint.listeners.removeDragListener(vertexDragListener);
-            curve.endControlPoint.listeners.removeDragListener(vertexDragListener);
-            if (i + 1 == path.bezierCurves.length && !path.adjustCircular)
-                curve.endPoint.listeners.removeDragListener(vertexDragListener);
-        }
-    }
-    /**
-     * A helper function to add drag-end listeners to all vertices of the given path.
-     *
-     * @static
-     * @method addPathVertexDragEndListeners
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The Bézier path to add vertex listeners to.
-     * @param {function} vertexDragEndListener - The drag listeners to add to each path vertex.
-     * @return void
-     **/
-    static addPathVertexDragEndListeners(path, vertexDragEndListener) {
-        for (var i = 0; i < path.bezierCurves.length; i++) {
-            const curve = path.bezierCurves[i];
-            curve.startPoint.listeners.addDragEndListener(vertexDragEndListener);
-            curve.startControlPoint.listeners.addDragEndListener(vertexDragEndListener);
-            curve.endControlPoint.listeners.addDragEndListener(vertexDragEndListener);
-            if (i + 1 == path.bezierCurves.length && !path.adjustCircular)
-                curve.endPoint.listeners.addDragEndListener(vertexDragEndListener);
-            // if( i+1 == path.bezierCurves.length && !path.adjustCircular )
-            // BezierPathIntractionHelper._addVertsDragListener( [curve.startPoint, curve.startControlPoint, curve.endPoint, curve.endControlPoint ], vertexDragListener );
-        }
-    }
-    /**
-     * A helper function to remove drag-end listeners to all vertices of the given path.
-     *
-     * @static
-     * @method removePathVertexDragEndListeners
-     * @memberof BezierPathInteractionHelper
-     * @param {BezierPath} path - The Bézier path to remove vertex listeners from.
-     * @param {function} vertexDragListener - The drag listeners to remove from each path vertex.
-     * @return void
-     **/
-    static removePathVertexDragEndListeners(path, vertexDragEndListener) {
-        for (var i = 0; i < path.bezierCurves.length; i++) {
-            const curve = path.bezierCurves[i];
-            curve.startPoint.listeners.removeDragEndListener(vertexDragEndListener);
-            curve.startControlPoint.listeners.removeDragEndListener(vertexDragEndListener);
-            curve.endControlPoint.listeners.removeDragEndListener(vertexDragEndListener);
-            if (i + 1 == path.bezierCurves.length && !path.adjustCircular)
-                curve.endPoint.listeners.removeDragEndListener(vertexDragEndListener);
-        }
-    }
-}
-exports.BezierPathInteractionHelper = BezierPathInteractionHelper;
-//# sourceMappingURL=BezierPathInteractionHelper.js.map