@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/routing/RoutingEngine.js

@@ -1,546 +0,0 @@
-"use strict";
-// RoutingEngine - Main routing coordinator
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutingEngine = void 0;
-const tslib_1 = require("tslib");
-const ObstacleMap_1 = require("./ObstacleMap");
-const ObstacleIndex_1 = require("./ObstacleIndex"); // Wave 8 Card 6
-const PathSimplifier_1 = require("./PathSimplifier"); // Phase 2.2
-const StraightRouter_1 = require("./algorithms/StraightRouter");
-const OrthogonalRouter_1 = require("./algorithms/OrthogonalRouter");
-const ManhattanRouter_1 = require("./algorithms/ManhattanRouter");
-const ElkRouter_1 = require("./algorithms/ElkRouter");
-const AStarRouter_1 = require("./algorithms/AStarRouter");
-const DijkstraRouter_1 = require("./algorithms/DijkstraRouter");
-const VisibilityGraphRouter_1 = require("./algorithms/VisibilityGraphRouter");
-const LRUCache_1 = require("../performance/LRUCache"); // Phase 5.3
-/**
- * Point the map a graph-router queries AT THE REQUEST'S obstacles.
- *
- * THE BUG THIS FIXES: `AStarRouter`/`DijkstraRouter`/`VisibilityGraphRouter` all read the
- * ObstacleMap they were handed at CONSTRUCTION. The adapters below used to pass the engine's
- * shared global map and then route `(start, end)` — so `request.obstacles`, the set
- * `RoutingEngine.route()` painstakingly resolves as globals ∪ request and hands over in
- * `enhancedRequest`, was IGNORED. A link routed `avoid` drew straight THROUGH any obstacle
- * that arrived via the request, because the router never saw it. (Orthogonal/manhattan honour
- * request.obstacles; these three did not — a silent inconsistency across the router set.)
- *
- * Each adapter now owns a PRIVATE map (never the shared global one, which resolveObstacles
- * still reads) and syncs it to the request's fully-resolved obstacle set per route. Costlier
- * than a stale reference, but these are the opt-in `avoid`-family routers, guarded by the
- * route cache above, and correctness is not optional.
- */
-function syncObstacles(map, request) {
-    var _a;
-    map.clear();
-    for (const o of (_a = request.obstacles) !== null && _a !== void 0 ? _a : [])
-        map.add(o);
-}
-/**
- * Adapter for A* Router to match IRouter interface
- */
-class AStarRouterAdapter {
-    constructor() {
-        this.obstacles = new ObstacleMap_1.ObstacleMap();
-        this.router = new AStarRouter_1.AStarRouter(this.obstacles);
-    }
-    getName() {
-        return 'a-star';
-    }
-    route(request) {
-        syncObstacles(this.obstacles, request);
-        const points = this.router.route(request.start, request.end);
-        if (points.length === 0)
-            return null;
-        // Calculate total length and bend count
-        let totalLength = 0;
-        let bendCount = 0;
-        for (let i = 0; i < points.length - 1; i++) {
-            const dx = points[i + 1].x - points[i].x;
-            const dy = points[i + 1].y - points[i].y;
-            totalLength += Math.sqrt(dx * dx + dy * dy);
-            // Count bends (direction changes)
-            if (i > 0) {
-                const prevDx = points[i].x - points[i - 1].x;
-                const prevDy = points[i].y - points[i - 1].y;
-                if (Math.abs(dx - prevDx) > 0.01 || Math.abs(dy - prevDy) > 0.01) {
-                    bendCount++;
-                }
-            }
-        }
-        return {
-            points,
-            totalLength,
-            bendCount,
-            cost: totalLength,
-        };
-    }
-}
-/**
- * Adapter for Dijkstra Router to match IRouter interface
- */
-class DijkstraRouterAdapter {
-    constructor() {
-        this.obstacles = new ObstacleMap_1.ObstacleMap();
-        this.router = new DijkstraRouter_1.DijkstraRouter(this.obstacles);
-    }
-    getName() {
-        return 'dijkstra';
-    }
-    route(request) {
-        syncObstacles(this.obstacles, request);
-        const points = this.router.route(request.start, request.end);
-        if (points.length === 0)
-            return null;
-        let totalLength = 0;
-        let bendCount = 0;
-        for (let i = 0; i < points.length - 1; i++) {
-            const dx = points[i + 1].x - points[i].x;
-            const dy = points[i + 1].y - points[i].y;
-            totalLength += Math.sqrt(dx * dx + dy * dy);
-            if (i > 0) {
-                const prevDx = points[i].x - points[i - 1].x;
-                const prevDy = points[i].y - points[i - 1].y;
-                if (Math.abs(dx - prevDx) > 0.01 || Math.abs(dy - prevDy) > 0.01) {
-                    bendCount++;
-                }
-            }
-        }
-        return {
-            points,
-            totalLength,
-            bendCount,
-            cost: totalLength,
-        };
-    }
-}
-/**
- * Adapter for Visibility Graph Router to match IRouter interface
- */
-class VisibilityGraphRouterAdapter {
-    constructor() {
-        this.obstacles = new ObstacleMap_1.ObstacleMap();
-        this.router = new VisibilityGraphRouter_1.VisibilityGraphRouter(this.obstacles);
-    }
-    getName() {
-        return 'visibility-graph';
-    }
-    route(request) {
-        syncObstacles(this.obstacles, request);
-        const points = this.router.route(request.start, request.end);
-        if (points.length === 0)
-            return null;
-        let totalLength = 0;
-        let bendCount = 0;
-        for (let i = 0; i < points.length - 1; i++) {
-            const dx = points[i + 1].x - points[i].x;
-            const dy = points[i + 1].y - points[i].y;
-            totalLength += Math.sqrt(dx * dx + dy * dy);
-            if (i > 0) {
-                const prevDx = points[i].x - points[i - 1].x;
-                const prevDy = points[i].y - points[i - 1].y;
-                if (Math.abs(dx - prevDx) > 0.01 || Math.abs(dy - prevDy) > 0.01) {
-                    bendCount++;
-                }
-            }
-        }
-        return {
-            points,
-            totalLength,
-            bendCount,
-            cost: totalLength,
-        };
-    }
-}
-/**
- * RoutingEngine coordinates routing operations and manages obstacles
- */
-class RoutingEngine {
-    constructor() {
-        this.routers = new Map();
-        this.obstacleMap = new ObstacleMap_1.ObstacleMap();
-        this.globalObstacles = []; // Simple array to avoid huge spatial queries
-        this.defaultAlgorithm = 'straight';
-        // ---------------------------------------------------------------------------
-        // Wave 8 (Performance & scale) — Card 6: the obstacle set, resolved once.
-        //
-        // `route()` merged the global obstacles with the request's on EVERY call:
-        //
-        //     const allObstacles = [...this.getAllGlobalObstacles(), ...request.obstacles];
-        //
-        // On a 5,000-node diagram that allocated a 9,998-entry array per link per
-        // frame — and every entry of it was then linearly scanned by the router's
-        // collision test, once per grid cell A* looked at. (It is 9,998 and not 4,998
-        // because the two sets OVERLAP: the engine registers every node globally, and
-        // the renderer passes the same nodes again. Both copies were scanned.)
-        //
-        // Now the merge is deduplicated and MEMOISED — on the global obstacle version
-        // and the identity of the request's array — and it carries a spatial index
-        // built alongside it. A frame that routes 700 links against one obstacle set
-        // builds that set, and its index, exactly once.
-        // ---------------------------------------------------------------------------
-        /** Bumped whenever the global obstacle set changes; invalidates the caches below. */
-        this.obstacleVersion = 0;
-        this.globalResolved = null;
-        this.resolvedCache = new WeakMap();
-        /** Memoised obstacle-id signature for the LRU key (a sort+join of 10k ids is not free). */
-        this.cacheKeySigs = new WeakMap();
-        // Phase 5.3: Initialize LRU cache with capacity of 1000 routes
-        // This prevents unbounded memory growth while maintaining good hit rate
-        this.routeCache = new LRUCache_1.LRUCache(1000);
-        // Phase 2.2: Initialize path simplifier
-        this.pathSimplifier = new PathSimplifier_1.PathSimplifier();
-        // Register built-in routers
-        this.registerRouter('straight', new StraightRouter_1.StraightRouter());
-        this.registerRouter('orthogonal', new OrthogonalRouter_1.OrthogonalRouter());
-        // Wave 5 Card 3: the grid router with JointJS+-parity knobs (step, padding,
-        // turn cost, no U-turns, loop cap, perpendicular ends by construction).
-        this.registerRouter('manhattan', new ManhattanRouter_1.ManhattanRouter());
-        this.registerRouter('elk', new ElkRouter_1.ElkRouter());
-        // Register advanced routers with obstacle avoidance (using adapters)
-        this.registerRouter('a-star', new AStarRouterAdapter());
-        this.registerRouter('dijkstra', new DijkstraRouterAdapter());
-        this.registerRouter('visibility-graph', new VisibilityGraphRouterAdapter());
-    }
-    /**
-     * Register a custom router
-     */
-    registerRouter(name, router) {
-        if (this.routers.has(name)) {
-            throw new Error(`Router '${name}' already registered`);
-        }
-        this.routers.set(name, router);
-    }
-    /**
-     * Unregister a router
-     */
-    unregisterRouter(name) {
-        return this.routers.delete(name);
-    }
-    /**
-     * Get list of available routing algorithms
-     */
-    getAvailableAlgorithms() {
-        return Array.from(this.routers.keys());
-    }
-    /**
-     * Set default routing algorithm
-     */
-    setDefaultAlgorithm(algorithm) {
-        if (!this.routers.has(algorithm)) {
-            throw new Error(`Router '${algorithm}' not found`);
-        }
-        this.defaultAlgorithm = algorithm;
-    }
-    /**
-     * Get default algorithm
-     */
-    getDefaultAlgorithm() {
-        return this.defaultAlgorithm;
-    }
-    /**
-     * Add a global obstacle
-     */
-    addObstacle(obstacle) {
-        this.obstacleMap.add(obstacle);
-        this.globalObstacles.push(obstacle);
-        this.obstacleVersion++;
-        this.clearCache(); // Invalidate cache when obstacles change
-    }
-    /**
-     * Remove a global obstacle
-     */
-    removeObstacle(id) {
-        const removed = this.obstacleMap.remove(id);
-        if (removed) {
-            this.globalObstacles = this.globalObstacles.filter((o) => o.id !== id);
-            this.obstacleVersion++;
-            this.clearCache();
-        }
-        return removed;
-    }
-    /**
-     * Update an existing obstacle's position/size
-     * More efficient than remove + add
-     */
-    updateObstacle(obstacle) {
-        // Remove old version
-        this.obstacleMap.remove(obstacle.id);
-        // Add updated version
-        this.obstacleMap.add(obstacle);
-        // Update in global array
-        const index = this.globalObstacles.findIndex((o) => o.id === obstacle.id);
-        if (index !== -1) {
-            this.globalObstacles[index] = obstacle;
-        }
-        else {
-            this.globalObstacles.push(obstacle);
-        }
-        this.obstacleVersion++;
-        this.clearCache(); // Invalidate cache when obstacles change
-    }
-    /**
-     * Get number of global obstacles
-     */
-    /** All registered obstacles — the map's own array accessor, passed through. */
-    getObstacles() {
-        return this.obstacleMap.getObstacles();
-    }
-    getObstacleCount() {
-        return this.globalObstacles.length;
-    }
-    /**
-     * Clear all global obstacles
-     */
-    clearObstacles() {
-        this.obstacleMap.clear();
-        this.globalObstacles = [];
-        this.obstacleVersion++;
-        this.clearCache();
-    }
-    /**
-     * Wave 8 — Card 6: the effective obstacle set for a request (globals ∪ the
-     * request's own), deduplicated, with a spatial index over exactly it.
-     *
-     * Memoised twice over:
-     *   - the globals-only answer, invalidated by `obstacleVersion`;
-     *   - the merged answer, keyed on the IDENTITY of the request's array — so a
-     *     renderer that hands every link in a frame the same obstacle array pays
-     *     for the merge and the index once, not once per link.
-     *
-     * A caller that builds a fresh array per link still gets a correct answer; it
-     * just pays for it, exactly as it did before this existed.
-     */
-    resolveObstacles(requestObstacles) {
-        if (!this.globalResolved || this.globalResolved.version !== this.obstacleVersion) {
-            const obstacles = this.getAllGlobalObstacles();
-            this.globalResolved = {
-                version: this.obstacleVersion,
-                obstacles,
-                index: new ObstacleIndex_1.ObstacleIndex(obstacles),
-            };
-        }
-        if (!requestObstacles || requestObstacles.length === 0) {
-            return this.globalResolved;
-        }
-        const hit = this.resolvedCache.get(requestObstacles);
-        if (hit && hit.version === this.obstacleVersion)
-            return hit;
-        const obstacles = (0, ObstacleIndex_1.mergeObstacles)(this.globalResolved.obstacles, requestObstacles);
-        const resolved = {
-            version: this.obstacleVersion,
-            obstacles,
-            index: new ObstacleIndex_1.ObstacleIndex(obstacles),
-        };
-        this.resolvedCache.set(requestObstacles, resolved);
-        return resolved;
-    }
-    /**
-     * Clear route cache
-     */
-    clearCache() {
-        this.routeCache.clear();
-    }
-    /**
-     * Route from start to end (synchronous version)
-     * Throws error if algorithm is async (like ELK)
-     * Use routeAsync() for async routers
-     */
-    route(request) {
-        var _a, _b, _c, _d;
-        // Validate coordinates
-        if (!isFinite(request.start.x) ||
-            !isFinite(request.start.y) ||
-            !isFinite(request.end.x) ||
-            !isFinite(request.end.y)) {
-            throw new Error('Invalid coordinates');
-        }
-        // Handle same start and end point
-        if (request.start.x === request.end.x &&
-            request.start.y === request.end.y) {
-            return {
-                points: [{ x: request.start.x, y: request.start.y }],
-                totalLength: 0,
-                bendCount: 0,
-                cost: 0,
-                segments: [],
-            };
-        }
-        // Check cache
-        const cacheKey = this.getCacheKey(request);
-        if (this.routeCache.has(cacheKey)) {
-            return this.routeCache.get(cacheKey);
-        }
-        // Get algorithm
-        const algorithm = (_b = (_a = request.options) === null || _a === void 0 ? void 0 : _a.algorithm) !== null && _b !== void 0 ? _b : this.defaultAlgorithm;
-        // ELK is async-only
-        if (algorithm === 'elk') {
-            throw new Error('ELK router is async. Use routeAsync() instead or pre-calculate paths.');
-        }
-        const router = this.routers.get(algorithm);
-        if (!router) {
-            throw new Error(`Router '${algorithm}' not found`);
-        }
-        // Wave 8 — Card 6: globals ∪ request, deduplicated and indexed, memoised.
-        const resolved = this.resolveObstacles(request.obstacles);
-        // Create enhanced request with all obstacles
-        const enhancedRequest = Object.assign(Object.assign({}, request), { obstacles: resolved.obstacles, obstacleIndex: resolved.index });
-        // Perform routing (must be sync)
-        const result = router.route(enhancedRequest);
-        if (result instanceof Promise) {
-            throw new Error(`Router '${algorithm}' is async. Use routeAsync() instead.`);
-        }
-        let path = result;
-        // Apply path simplification if enabled
-        if (path && ((_c = request.options) === null || _c === void 0 ? void 0 : _c.simplifyPath) && path.points.length > 2) {
-            const epsilon = (_d = request.options.simplificationEpsilon) !== null && _d !== void 0 ? _d : 1.0;
-            const simplifiedPoints = this.pathSimplifier.simplify(path.points, epsilon);
-            // Recalculate path metrics after simplification
-            let totalLength = 0;
-            let bendCount = 0;
-            for (let i = 0; i < simplifiedPoints.length - 1; i++) {
-                const dx = simplifiedPoints[i + 1].x - simplifiedPoints[i].x;
-                const dy = simplifiedPoints[i + 1].y - simplifiedPoints[i].y;
-                totalLength += Math.sqrt(dx * dx + dy * dy);
-                // Count bends (direction changes)
-                if (i > 0) {
-                    const prevDx = simplifiedPoints[i].x - simplifiedPoints[i - 1].x;
-                    const prevDy = simplifiedPoints[i].y - simplifiedPoints[i - 1].y;
-                    if (Math.abs(dx - prevDx) > 0.01 || Math.abs(dy - prevDy) > 0.01) {
-                        bendCount++;
-                    }
-                }
-            }
-            // Create new path with simplified points
-            path = Object.assign(Object.assign({}, path), { points: simplifiedPoints, totalLength,
-                bendCount });
-        }
-        // Cache result
-        this.routeCache.set(cacheKey, path);
-        return path;
-    }
-    /**
-     * Route from start to end (async version)
-     * Supports both sync and async routers like ELK.js
-     */
-    routeAsync(request) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            // Validate coordinates
-            if (!isFinite(request.start.x) ||
-                !isFinite(request.start.y) ||
-                !isFinite(request.end.x) ||
-                !isFinite(request.end.y)) {
-                throw new Error('Invalid coordinates');
-            }
-            // Handle same start and end point
-            if (request.start.x === request.end.x &&
-                request.start.y === request.end.y) {
-                return {
-                    points: [{ x: request.start.x, y: request.start.y }],
-                    totalLength: 0,
-                    bendCount: 0,
-                    cost: 0,
-                    segments: [],
-                };
-            }
-            // Check cache
-            const cacheKey = this.getCacheKey(request);
-            if (this.routeCache.has(cacheKey)) {
-                return this.routeCache.get(cacheKey);
-            }
-            // Get algorithm
-            const algorithm = (_b = (_a = request.options) === null || _a === void 0 ? void 0 : _a.algorithm) !== null && _b !== void 0 ? _b : this.defaultAlgorithm;
-            const router = this.routers.get(algorithm);
-            if (!router) {
-                throw new Error(`Router '${algorithm}' not found`);
-            }
-            // Wave 8 — Card 6: globals ∪ request, deduplicated and indexed, memoised.
-            const resolved = this.resolveObstacles(request.obstacles);
-            // Create enhanced request with all obstacles
-            const enhancedRequest = Object.assign(Object.assign({}, request), { obstacles: resolved.obstacles, obstacleIndex: resolved.index });
-            // Perform routing (await in case router is async like ELK)
-            let path = yield router.route(enhancedRequest);
-            // Phase 2.2: Apply path simplification if enabled
-            if (path && ((_c = request.options) === null || _c === void 0 ? void 0 : _c.simplifyPath) && path.points.length > 2) {
-                const epsilon = (_d = request.options.simplificationEpsilon) !== null && _d !== void 0 ? _d : 1.0;
-                const simplifiedPoints = this.pathSimplifier.simplify(path.points, epsilon);
-                // Recalculate path metrics after simplification
-                let totalLength = 0;
-                let bendCount = 0;
-                for (let i = 0; i < simplifiedPoints.length - 1; i++) {
-                    const dx = simplifiedPoints[i + 1].x - simplifiedPoints[i].x;
-                    const dy = simplifiedPoints[i + 1].y - simplifiedPoints[i].y;
-                    totalLength += Math.sqrt(dx * dx + dy * dy);
-                    // Count bends (direction changes)
-                    if (i > 0) {
-                        const prevDx = simplifiedPoints[i].x - simplifiedPoints[i - 1].x;
-                        const prevDy = simplifiedPoints[i].y - simplifiedPoints[i - 1].y;
-                        if (Math.abs(dx - prevDx) > 0.01 || Math.abs(dy - prevDy) > 0.01) {
-                            bendCount++;
-                        }
-                    }
-                }
-                // Create new path with simplified points
-                path = Object.assign(Object.assign({}, path), { points: simplifiedPoints, totalLength,
-                    bendCount });
-            }
-            // Cache result
-            this.routeCache.set(cacheKey, path);
-            return path;
-        });
-    }
-    /**
-     * Get routing engine statistics
-     */
-    getStats() {
-        return {
-            obstacleCount: this.obstacleMap.size(),
-            routerCount: this.routers.size,
-            cacheSize: this.routeCache.size(), // Phase 5.3: LRUCache uses method instead of property
-        };
-    }
-    /**
-     * Get all global obstacles
-     */
-    getAllGlobalObstacles() {
-        return this.globalObstacles;
-    }
-    /**
-     * Generate cache key for a route request
-     */
-    getCacheKey(request) {
-        var _a, _b, _c, _d, _e, _f;
-        const algo = (_b = (_a = request.options) === null || _a === void 0 ? void 0 : _a.algorithm) !== null && _b !== void 0 ? _b : this.defaultAlgorithm;
-        const simplify = (_d = (_c = request.options) === null || _c === void 0 ? void 0 : _c.simplifyPath) !== null && _d !== void 0 ? _d : false;
-        const epsilon = (_f = (_e = request.options) === null || _e === void 0 ? void 0 : _e.simplificationEpsilon) !== null && _f !== void 0 ? _f : 1.0;
-        const obstacleIds = this.obstacleSignature(request.obstacles);
-        // Phase 2.2: Include simplification options in cache key to prevent incorrect cache hits
-        return `${request.start.x},${request.start.y}|${request.end.x},${request.end.y}|${algo}|${obstacleIds}|${simplify}|${epsilon}`;
-    }
-    /**
-     * Wave 8 — Card 6: the obstacle-id part of the LRU key.
-     *
-     * This used to `.map().sort().join()` the request's obstacle array on EVERY
-     * route call — an O(n log n) sort and an ~80KB string per link on a 10k-node
-     * diagram, purely to look up a cache. Memoised on the array's identity: the
-     * ids of an array cannot change without a new array (the renderer rebuilds
-     * one per frame), and any change to the GLOBAL obstacles already clears the
-     * whole cache, so a stale signature cannot outlive the entry it keys.
-     */
-    obstacleSignature(obstacles) {
-        if (!obstacles || obstacles.length === 0)
-            return '';
-        const hit = this.cacheKeySigs.get(obstacles);
-        if (hit !== undefined)
-            return hit;
-        const sig = obstacles
-            .map((o) => o.id)
-            .sort()
-            .join(',');
-        this.cacheKeySigs.set(obstacles, sig);
-        return sig;
-    }
-}
-exports.RoutingEngine = RoutingEngine;
-//# sourceMappingURL=RoutingEngine.js.map

package/src/libs/engine/src/routing/algorithms/AStarRouter.d.ts

@@ -1,90 +0,0 @@
-import type { Point } from '../../types';
-import type { ObstacleMap } from '../ObstacleMap';
-/**
- * Heuristic functions for A* algorithm
- */
-export declare enum AStarHeuristic {
-    /** Manhattan distance (L1 norm) - best for grid-based movement */
-    MANHATTAN = "manhattan",
-    /** Euclidean distance (L2 norm) - best for free movement */
-    EUCLIDEAN = "euclidean",
-    /** Diagonal distance (Chebyshev/L∞ norm) - best for 8-directional movement */
-    DIAGONAL = "diagonal"
-}
-/**
- * Configuration options for A* router
- */
-export interface AStarOptions {
-    /** Heuristic function to use (default: MANHATTAN) */
-    heuristic?: AStarHeuristic;
-    /** Allow diagonal movement (default: true) */
-    allowDiagonal?: boolean;
-    /** Grid size for discretization (default: 5) */
-    gridSize?: number;
-    /** Enable path smoothing (default: true) */
-    smoothing?: boolean;
-    /** Margin around obstacles (default: 5) */
-    obstacleMargin?: number;
-    /** Maximum iterations before giving up (default: 10000) */
-    maxIterations?: number;
-}
-/**
- * A* Pathfinding Router
- */
-export declare class AStarRouter {
-    private obstacleMap;
-    private options;
-    constructor(obstacleMap: ObstacleMap, options?: AStarOptions);
-    /**
-     * Get algorithm name
-     */
-    getName(): string;
-    /**
-     * Find path from start to end using A* algorithm
-     */
-    route(start: Point, end: Point): Point[];
-    /**
-     * Core A* pathfinding algorithm
-     */
-    private findPath;
-    /**
-     * Reconstruct path from end node
-     */
-    private reconstructPath;
-    /**
-     * Get neighbors of a point
-     */
-    private getNeighbors;
-    /**
-     * Calculate heuristic distance
-     */
-    private heuristic;
-    /**
-     * Calculate actual distance between two points
-     */
-    private distance;
-    /**
-     * Check if point collides with obstacle (including margin)
-     */
-    private collidesWithObstacle;
-    /**
-     * Smooth path by removing unnecessary waypoints
-     */
-    private smoothPath;
-    /**
-     * Check if there's a clear line of sight between two points
-     */
-    private hasLineOfSight;
-    /**
-     * Snap point to grid
-     */
-    private snapToGrid;
-    /**
-     * Create unique key for point
-     */
-    private pointKey;
-    /**
-     * Check if two points are equal
-     */
-    private pointsEqual;
-}