@rxflow/manhattan 0.0.2-alpha.8 → 0.0.2

package/cjs/getManHattanPath.js

@@ -1,418 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getManHattanPath = getManHattanPath;
-var _react = require("@xyflow/react");
-var _geometry = require("./geometry");
-var _obstacle = require("./obstacle");
-var _options = require("./options");
-var _pathfinder = require("./pathfinder");
-var _svg = require("./svg");
-var _utils = require("./utils");
-/**
- * Parameters for getManHattanPath function
- */
-
-/**
- * Generate Manhattan-routed path for ReactFlow edges
- *
- * @param params - Path generation parameters
- * @returns SVG path string that can be used with ReactFlow's BaseEdge
- *
- * @example
- * ```typescript
- * const path = getManHattanPath({
- *   sourceNodeId: 'node1',
- *   targetNodeId: 'node2',
- *   sourcePosition: { x: 100, y: 100 },
- *   targetPosition: { x: 300, y: 300 },
- *   nodeLookup: nodes,
- *   options: {
- *     step: 10,
- *     startDirections: ['bottom'],
- *     endDirections: ['top']
- *   }
- * })
- * ```
- */
-function getManHattanPath(params) {
-  const {
-    sourceNodeId,
-    targetNodeId,
-    sourcePosition,
-    targetPosition,
-    nodeLookup,
-    sourceX,
-    sourceY,
-    targetX,
-    targetY,
-    options: userOptions = {}
-  } = params;
-
-  // Resolve options and add position information
-  const options = (0, _options.resolveOptions)({
-    ...userOptions,
-    sourcePosition,
-    targetPosition
-  });
-
-  // Direction control is automatically handled by getRectPoints:
-  // - When anchor is on an edge, only outward directions are allowed (via isDirectionOutward)
-  // - For sourcePosition="right": anchor on right edge -> only extends right
-  // - For targetPosition="left": anchor on left edge -> path approaches from right (outward from left)
-  // This ensures paths follow the sourcePosition and targetPosition constraints
-
-  // Get source and target nodes
-  const sourceNode = nodeLookup.get(sourceNodeId);
-  const targetNode = nodeLookup.get(targetNodeId);
-  if (!sourceNode || !targetNode) {
-    // Fallback to simple straight line if nodes not found
-    console.warn('Source or target node not found in nodeLookup');
-    const start = new _geometry.Point(sourceX, sourceY);
-    const end = new _geometry.Point(targetX, targetY);
-    return (0, _svg.pointsToPath)([start, end], options.precision);
-  }
-
-  // Get node dimensions using ReactFlow's priority logic
-  const sourceDimensions = (0, _utils.getNodeDimensions)(sourceNode);
-  const targetDimensions = (0, _utils.getNodeDimensions)(targetNode);
-
-  // Get absolute positions from internals
-  const sourcePos = (0, _utils.getNodePosition)(sourceNode);
-  const targetPos = (0, _utils.getNodePosition)(targetNode);
-
-  // Calculate bounding boxes
-  const sourceBBox = new _geometry.Rectangle(sourcePos.x, sourcePos.y, sourceDimensions.width, sourceDimensions.height);
-  const targetBBox = new _geometry.Rectangle(targetPos.x, targetPos.y, targetDimensions.width, targetDimensions.height);
-
-  // Create anchor points
-  const sourceAnchor = new _geometry.Point(sourceX, sourceY);
-  const targetAnchor = new _geometry.Point(targetX, targetY);
-
-  // Try ReactFlow's getSmoothStepPath first
-  const [smoothStepPath] = (0, _react.getSmoothStepPath)({
-    sourceX,
-    sourceY,
-    targetX,
-    targetY,
-    sourcePosition,
-    targetPosition,
-    borderRadius: options.borderRadius
-  });
-
-  // Parse the smooth step path to extract points
-  const smoothStepPoints = (0, _svg.parseSVGPath)(smoothStepPath);
-
-  // Check if smooth step path intersects with any obstacles
-  if (smoothStepPoints.length > 0 && !(0, _utils.pathIntersectsObstacles)(smoothStepPoints, nodeLookup)) {
-    console.log('[getManHattanPath] Using ReactFlow getSmoothStepPath (no obstacles)');
-    return smoothStepPath;
-  }
-  console.log('[getManHattanPath] SmoothStepPath intersects obstacles, using Manhattan routing');
-
-  // Build obstacle map with anchor information
-  const obstacleMap = new _obstacle.ObstacleMap(options).build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor);
-
-  // Find route
-  let route = (0, _pathfinder.findRoute)(sourceBBox, targetBBox, sourceAnchor, targetAnchor, obstacleMap, options);
-
-  // Fallback to straight line if no route found
-  if (!route) {
-    console.warn('Unable to find Manhattan route, using straight line fallback');
-    route = [sourceAnchor, targetAnchor];
-  }
-  console.log('[getManHattanPath] Route from findRoute:', route.map(p => `(${p.x}, ${p.y})`));
-  console.log('[getManHattanPath] Source anchor:', `(${sourceAnchor.x}, ${sourceAnchor.y})`);
-  console.log('[getManHattanPath] Target anchor:', `(${targetAnchor.x}, ${targetAnchor.y})`);
-
-  // If using smart point generation (sourcePosition/targetPosition specified),
-  // the route already contains the correct extension points, so skip manual processing
-  const useSmartPoints = sourcePosition || targetPosition;
-  if (useSmartPoints) {
-    console.log('[getManHattanPath] Using smart points, skipping manual extension point processing');
-    // Add source and target anchors to route
-    const finalRoute = [sourceAnchor, ...route, targetAnchor];
-    console.log('[getManHattanPath] Final route:', finalRoute.map(p => `(${p.x}, ${p.y})`));
-    return (0, _svg.pointsToPath)(finalRoute, options.precision, options.borderRadius);
-  }
-
-  // Remove extension points from route that were added by getRectPoints
-  // We will add our own with fixed step distance
-  const step = options.step;
-  const tolerance = 1;
-
-  // Check if first point is an extension point from source
-  if (route.length > 0) {
-    const firstPoint = route[0];
-    const onLeft = Math.abs(sourceAnchor.x - sourceBBox.x) < tolerance;
-    const onRight = Math.abs(sourceAnchor.x - (sourceBBox.x + sourceBBox.width)) < tolerance;
-    const onTop = Math.abs(sourceAnchor.y - sourceBBox.y) < tolerance;
-    const onBottom = Math.abs(sourceAnchor.y - (sourceBBox.y + sourceBBox.height)) < tolerance;
-
-    // Check if firstPoint is close to source anchor (indicating it's an extension point)
-    const distToFirst = sourceAnchor.manhattanDistance(firstPoint);
-    if (distToFirst < step * 2) {
-      // This is likely an extension point, remove it
-      if (onRight && firstPoint.x > sourceAnchor.x || onLeft && firstPoint.x < sourceAnchor.x || onBottom && firstPoint.y > sourceAnchor.y || onTop && firstPoint.y < sourceAnchor.y) {
-        route.shift();
-        console.log('[getManHattanPath] Removed extension point from route start');
-      }
-    }
-  }
-
-  // Check if last point is an extension point from target
-  if (route.length > 0) {
-    const lastPoint = route[route.length - 1];
-    const onLeft = Math.abs(targetAnchor.x - targetBBox.x) < tolerance;
-    const onRight = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < tolerance;
-    const onTop = Math.abs(targetAnchor.y - targetBBox.y) < tolerance;
-    const onBottom = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < tolerance;
-
-    // Check if lastPoint is close to target anchor (indicating it's an extension point)
-    const distToLast = targetAnchor.manhattanDistance(lastPoint);
-    if (distToLast < step * 2) {
-      // This is likely an extension point, remove it
-      if (onLeft && lastPoint.x < targetAnchor.x || onRight && lastPoint.x > targetAnchor.x || onTop && lastPoint.y < targetAnchor.y || onBottom && lastPoint.y > targetAnchor.y) {
-        route.pop();
-        console.log('[getManHattanPath] Removed extension point from route end');
-      }
-    }
-  }
-
-  // Insert extension point at source - always extend away from node edge by fixed distance
-  if (route.length > 0) {
-    const extensionDistance = options.extensionDistance;
-    const firstPoint = route[0];
-
-    // Determine which edge the source anchor is on
-    const onLeft = Math.abs(sourceAnchor.x - sourceBBox.x) < tolerance;
-    const onRight = Math.abs(sourceAnchor.x - (sourceBBox.x + sourceBBox.width)) < tolerance;
-    const onTop = Math.abs(sourceAnchor.y - sourceBBox.y) < tolerance;
-    const onBottom = Math.abs(sourceAnchor.y - (sourceBBox.y + sourceBBox.height)) < tolerance;
-
-    // Insert extension point and corner point to ensure orthogonal path
-    if (onRight) {
-      // Anchor on right edge - extend right by step + borderRadius
-      const extendX = sourceAnchor.x + extensionDistance;
-      const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
-      // Check if we need a corner point
-      if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
-        route.unshift(new _geometry.Point(extendX, firstPoint.y)); // Corner point
-      }
-      route.unshift(extensionPoint); // Extension point (fixed distance)
-      console.log('[getManHattanPath] Inserted source extension (right):', `(${extendX}, ${sourceAnchor.y})`);
-    } else if (onLeft) {
-      // Anchor on left edge - extend left by step + borderRadius
-      const extendX = sourceAnchor.x - extensionDistance;
-      const extensionPoint = new _geometry.Point(extendX, sourceAnchor.y);
-      if (Math.abs(extensionPoint.y - firstPoint.y) > tolerance) {
-        route.unshift(new _geometry.Point(extendX, firstPoint.y));
-      }
-      route.unshift(extensionPoint);
-      console.log('[getManHattanPath] Inserted source extension (left):', `(${extendX}, ${sourceAnchor.y})`);
-    } else if (onBottom) {
-      // Anchor on bottom edge - extend down by step + borderRadius
-      const extendY = sourceAnchor.y + extensionDistance;
-      const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
-      if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
-        route.unshift(new _geometry.Point(firstPoint.x, extendY));
-      }
-      route.unshift(extensionPoint);
-      console.log('[getManHattanPath] Inserted source extension (down):', `(${sourceAnchor.x}, ${extendY})`);
-    } else if (onTop) {
-      // Anchor on top edge - extend up by step + borderRadius
-      const extendY = sourceAnchor.y - extensionDistance;
-      const extensionPoint = new _geometry.Point(sourceAnchor.x, extendY);
-      if (Math.abs(extensionPoint.x - firstPoint.x) > tolerance) {
-        route.unshift(new _geometry.Point(firstPoint.x, extendY));
-      }
-      route.unshift(extensionPoint);
-      console.log('[getManHattanPath] Inserted source extension (up):', `(${sourceAnchor.x}, ${extendY})`);
-    }
-  }
-
-  // Remove redundant points after source extension
-  // If the first route point has the same x or y coordinate as the source anchor, it's redundant
-  if (route.length > 2) {
-    const firstRoutePoint = route[0]; // Extension point
-    const secondRoutePoint = route[1]; // Corner point (if exists)
-    const thirdRoutePoint = route[2]; // Original A* point
-
-    // Check if the third point (original A* point) is redundant
-    // It's redundant if it's on the same line as the corner point and can be skipped
-    const sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
-    const sameY = Math.abs(thirdRoutePoint.y - sourceAnchor.y) < tolerance;
-    if (sameX || sameY) {
-      // The third point is aligned with the source anchor, likely redundant
-      // Check if we can skip it by connecting corner point directly to the next point
-      if (route.length > 3) {
-        const fourthPoint = route[3];
-        // If corner point and fourth point form a straight line, remove the third point
-        const cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
-        const thirdToFourth = Math.abs(thirdRoutePoint.x - fourthPoint.x) < tolerance || Math.abs(thirdRoutePoint.y - fourthPoint.y) < tolerance;
-        if (cornerToThird && thirdToFourth) {
-          console.log('[getManHattanPath] Removing redundant point:', `(${thirdRoutePoint.x}, ${thirdRoutePoint.y})`);
-          route.splice(2, 1); // Remove the third point
-        }
-      }
-    }
-  }
-
-  // Optimize zigzag patterns BEFORE inserting target extension
-  // Check for patterns like: (1360, 16) -> (815, 16) -> (815, -134)
-  // where the middle segment goes to target edge and then moves along it
-  // Use target bbox with padding (same as ObstacleMap)
-  const targetBBoxWithPadding = targetBBox.moveAndExpand(options.paddingBox);
-  console.log('[getManHattanPath] Route before zigzag check:', route.map(p => `(${p.x}, ${p.y})`));
-  console.log('[getManHattanPath] Target BBox with padding:', `x=${targetBBoxWithPadding.x}, y=${targetBBoxWithPadding.y}`);
-  if (route.length >= 3) {
-    let i = 0;
-    while (i < route.length - 2) {
-      const p1 = route[i];
-      const p2 = route[i + 1];
-      const p3 = route[i + 2];
-
-      // Check if p2 is on the target bbox edge (with padding)
-      const p2OnTargetLeftEdge = Math.abs(p2.x - targetBBoxWithPadding.x) < tolerance;
-      const p2OnTargetRightEdge = Math.abs(p2.x - (targetBBoxWithPadding.x + targetBBoxWithPadding.width)) < tolerance;
-      const p2OnTargetTopEdge = Math.abs(p2.y - targetBBoxWithPadding.y) < tolerance;
-      const p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBoxWithPadding.y + targetBBoxWithPadding.height)) < tolerance;
-      const p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
-      console.log(`[getManHattanPath] Checking i=${i}: p2=(${p2.x}, ${p2.y}), onEdge=${p2OnTargetEdge}`);
-      if (p2OnTargetEdge) {
-        // Check if p1 -> p2 -> p3 forms a zigzag
-        const p1ToP2Horizontal = Math.abs(p1.y - p2.y) < tolerance;
-        const p2ToP3Vertical = Math.abs(p2.x - p3.x) < tolerance;
-        const p1ToP2Vertical = Math.abs(p1.x - p2.x) < tolerance;
-        const p2ToP3Horizontal = Math.abs(p2.y - p3.y) < tolerance;
-        console.log(`[getManHattanPath] Zigzag pattern: H->V=${p1ToP2Horizontal && p2ToP3Vertical}, V->H=${p1ToP2Vertical && p2ToP3Horizontal}`);
-        if (p1ToP2Horizontal && p2ToP3Vertical || p1ToP2Vertical && p2ToP3Horizontal) {
-          // We have a zigzag at target edge, remove p2 and p3
-          console.log('[getManHattanPath] Removing zigzag at target edge:', `(${p2.x}, ${p2.y})`, `and (${p3.x}, ${p3.y})`);
-          route.splice(i + 1, 2); // Remove p2 and p3
-          continue;
-        }
-      }
-      i++;
-    }
-  }
-
-  // Insert extension point at target - always extend away from node edge by fixed distance
-  if (route.length > 0) {
-    const extensionDistance = options.extensionDistance;
-    const lastPoint = route[route.length - 1];
-
-    // Determine which edge the target anchor is on
-    const onLeft = Math.abs(targetAnchor.x - targetBBox.x) < tolerance;
-    const onRight = Math.abs(targetAnchor.x - (targetBBox.x + targetBBox.width)) < tolerance;
-    const onTop = Math.abs(targetAnchor.y - targetBBox.y) < tolerance;
-    const onBottom = Math.abs(targetAnchor.y - (targetBBox.y + targetBBox.height)) < tolerance;
-
-    // Insert extension point and corner point to ensure orthogonal path
-    if (onLeft) {
-      // Anchor on left edge - extend left by step + borderRadius
-      const extendX = targetAnchor.x - extensionDistance;
-      const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
-      if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
-        route.push(new _geometry.Point(extendX, lastPoint.y)); // Corner point
-      }
-      route.push(extensionPoint); // Extension point (fixed distance)
-      console.log('[getManHattanPath] Inserted target extension (left):', `(${extendX}, ${targetAnchor.y})`);
-    } else if (onRight) {
-      // Anchor on right edge - extend right by step + borderRadius
-      const extendX = targetAnchor.x + extensionDistance;
-      const extensionPoint = new _geometry.Point(extendX, targetAnchor.y);
-      if (Math.abs(extensionPoint.y - lastPoint.y) > tolerance) {
-        route.push(new _geometry.Point(extendX, lastPoint.y));
-      }
-      route.push(extensionPoint);
-      console.log('[getManHattanPath] Inserted target extension (right):', `(${extendX}, ${targetAnchor.y})`);
-    } else if (onTop) {
-      // Anchor on top edge - extend up by step + borderRadius
-      const extendY = targetAnchor.y - extensionDistance;
-      const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
-      if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
-        route.push(new _geometry.Point(lastPoint.x, extendY));
-      }
-      route.push(extensionPoint);
-      console.log('[getManHattanPath] Inserted target extension (up):', `(${targetAnchor.x}, ${extendY})`);
-    } else if (onBottom) {
-      // Anchor on bottom edge - extend down by step + borderRadius
-      const extendY = targetAnchor.y + extensionDistance;
-      const extensionPoint = new _geometry.Point(targetAnchor.x, extendY);
-      if (Math.abs(extensionPoint.x - lastPoint.x) > tolerance) {
-        route.push(new _geometry.Point(lastPoint.x, extendY));
-      }
-      route.push(extensionPoint);
-      console.log('[getManHattanPath] Inserted target extension (down):', `(${targetAnchor.x}, ${extendY})`);
-    }
-  }
-
-  // Remove redundant points before target extension
-  // Similar logic for target side
-  if (route.length > 2) {
-    const lastIdx = route.length - 1;
-    const lastRoutePoint = route[lastIdx]; // Extension point
-    const secondLastPoint = route[lastIdx - 1]; // Corner point (if exists)
-    const thirdLastPoint = route[lastIdx - 2]; // Original A* point
-
-    // Check if the third-to-last point is redundant
-    const sameX = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
-    const sameY = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
-    if (sameX || sameY) {
-      if (route.length > 3) {
-        const fourthLastPoint = route[lastIdx - 3];
-        const fourthToThird = Math.abs(fourthLastPoint.x - thirdLastPoint.x) < tolerance || Math.abs(fourthLastPoint.y - thirdLastPoint.y) < tolerance;
-        const thirdToSecond = Math.abs(thirdLastPoint.x - secondLastPoint.x) < tolerance || Math.abs(thirdLastPoint.y - secondLastPoint.y) < tolerance;
-        if (fourthToThird && thirdToSecond) {
-          console.log('[getManHattanPath] Removing redundant point:', `(${thirdLastPoint.x}, ${thirdLastPoint.y})`);
-          route.splice(lastIdx - 2, 1); // Remove the third-to-last point
-        }
-      }
-    }
-  }
-
-  // Additional optimization: Remove unnecessary zigzag patterns near target
-  // Check for patterns like: (1360, 16) -> (815, 16) -> (815, -134) -> (800, -134)
-  // where (815, 16) and (815, -134) form a zigzag at the target edge
-  let i = 0;
-  while (i < route.length - 2) {
-    const p1 = route[i];
-    const p2 = route[i + 1];
-    const p3 = route[i + 2];
-
-    // Check if p2 is on the target bbox edge
-    const p2OnTargetLeftEdge = Math.abs(p2.x - targetBBox.x) < tolerance;
-    const p2OnTargetRightEdge = Math.abs(p2.x - (targetBBox.x + targetBBox.width)) < tolerance;
-    const p2OnTargetTopEdge = Math.abs(p2.y - targetBBox.y) < tolerance;
-    const p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBox.y + targetBBox.height)) < tolerance;
-    const p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
-    if (p2OnTargetEdge) {
-      // Check if p1 -> p2 -> p3 forms a zigzag
-      const p1ToP2Horizontal = Math.abs(p1.y - p2.y) < tolerance;
-      const p2ToP3Vertical = Math.abs(p2.x - p3.x) < tolerance;
-      if (p1ToP2Horizontal && p2ToP3Vertical && i < route.length - 3) {
-        // We have horizontal -> vertical at target edge
-        // Check if we can skip p2 and p3
-        const p4 = route[i + 3];
-        const p3ToP4Horizontal = Math.abs(p3.y - p4.y) < tolerance;
-        if (p3ToP4Horizontal) {
-          // Pattern: horizontal -> vertical -> horizontal (zigzag)
-          console.log('[getManHattanPath] Removing zigzag at target edge:', `(${p2.x}, ${p2.y})`, `and (${p3.x}, ${p3.y})`);
-          route.splice(i + 1, 2); // Remove p2 and p3
-          continue;
-        }
-      }
-    }
-    i++;
-  }
-
-  // Add source and target anchors to route
-  const finalRoute = [sourceAnchor, ...route, targetAnchor];
-  console.log('[getManHattanPath] Final route:', finalRoute.map(p => `(${p.x}, ${p.y})`));
-
-  // Convert to SVG path string
-  return (0, _svg.pointsToPath)(finalRoute, options.precision, options.borderRadius);
-}

package/cjs/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * ReactFlow Manhattan Router
- *
- * A Manhattan routing algorithm adapted for ReactFlow from AntV X6.
- * Generates orthogonal (right-angle) paths that intelligently avoid obstacles.
- *
- * @packageDocumentation
- */
-export { getManHattanPath } from './getManHattanPath';
-export type { GetManHattanPathParams } from './getManHattanPath';
-export type { Direction, InternalNode, NodeLookup, ManhattanRouterOptions, ResolvedOptions, } from './options';
-export { Point, Rectangle, Line } from './geometry';
-export { getGrid, align, snapToGrid, getDirectionAngle, getDirectionChange, getRectPoints, getCost, getKey, reconstructRoute, normalizePoint, getNodeDimensions, getNodePosition, } from './utils';
-export type { NodeDimensions } from './utils';
-export { pointsToPath, snapPathToGrid } from './svg';
-//# sourceMappingURL=index.d.ts.map

package/cjs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAGhE,YAAY,EACV,SAAS,EACT,YAAY,EACZ,UAAU,EACV,sBAAsB,EACtB,eAAe,GAChB,MAAM,WAAW,CAAA;AAGlB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAGnD,OAAO,EACL,OAAO,EACP,KAAK,EACL,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,OAAO,EACP,MAAM,EACN,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,MAAM,SAAS,CAAA;AAGhB,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAG7C,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA"}

package/cjs/index.js

@@ -1,117 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "Line", {
-  enumerable: true,
-  get: function () {
-    return _geometry.Line;
-  }
-});
-Object.defineProperty(exports, "Point", {
-  enumerable: true,
-  get: function () {
-    return _geometry.Point;
-  }
-});
-Object.defineProperty(exports, "Rectangle", {
-  enumerable: true,
-  get: function () {
-    return _geometry.Rectangle;
-  }
-});
-Object.defineProperty(exports, "align", {
-  enumerable: true,
-  get: function () {
-    return _utils.align;
-  }
-});
-Object.defineProperty(exports, "getCost", {
-  enumerable: true,
-  get: function () {
-    return _utils.getCost;
-  }
-});
-Object.defineProperty(exports, "getDirectionAngle", {
-  enumerable: true,
-  get: function () {
-    return _utils.getDirectionAngle;
-  }
-});
-Object.defineProperty(exports, "getDirectionChange", {
-  enumerable: true,
-  get: function () {
-    return _utils.getDirectionChange;
-  }
-});
-Object.defineProperty(exports, "getGrid", {
-  enumerable: true,
-  get: function () {
-    return _utils.getGrid;
-  }
-});
-Object.defineProperty(exports, "getKey", {
-  enumerable: true,
-  get: function () {
-    return _utils.getKey;
-  }
-});
-Object.defineProperty(exports, "getManHattanPath", {
-  enumerable: true,
-  get: function () {
-    return _getManHattanPath.getManHattanPath;
-  }
-});
-Object.defineProperty(exports, "getNodeDimensions", {
-  enumerable: true,
-  get: function () {
-    return _utils.getNodeDimensions;
-  }
-});
-Object.defineProperty(exports, "getNodePosition", {
-  enumerable: true,
-  get: function () {
-    return _utils.getNodePosition;
-  }
-});
-Object.defineProperty(exports, "getRectPoints", {
-  enumerable: true,
-  get: function () {
-    return _utils.getRectPoints;
-  }
-});
-Object.defineProperty(exports, "normalizePoint", {
-  enumerable: true,
-  get: function () {
-    return _utils.normalizePoint;
-  }
-});
-Object.defineProperty(exports, "pointsToPath", {
-  enumerable: true,
-  get: function () {
-    return _svg.pointsToPath;
-  }
-});
-Object.defineProperty(exports, "reconstructRoute", {
-  enumerable: true,
-  get: function () {
-    return _utils.reconstructRoute;
-  }
-});
-Object.defineProperty(exports, "snapPathToGrid", {
-  enumerable: true,
-  get: function () {
-    return _svg.snapPathToGrid;
-  }
-});
-Object.defineProperty(exports, "snapToGrid", {
-  enumerable: true,
-  get: function () {
-    return _utils.snapToGrid;
-  }
-});
-var _getManHattanPath = require("./getManHattanPath");
-var _geometry = require("./geometry");
-var _utils = require("./utils");
-var _svg = require("./svg");

package/cjs/obstacle/ObstacleMap.d.ts

@@ -1,34 +0,0 @@
-import { Point } from '../geometry';
-import type { ResolvedOptions, NodeLookup } from '../options';
-/**
- * ObstacleMap class for managing obstacles in pathfinding
- * Uses a grid-based spatial partitioning for efficient queries
- */
-export declare class ObstacleMap {
-    private options;
-    private mapGridSize;
-    private map;
-    private sourceAnchor?;
-    private targetAnchor?;
-    constructor(options: ResolvedOptions);
-    /**
-     * Build obstacle map from node lookup
-     */
-    build(nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string, sourceAnchor?: Point, targetAnchor?: Point): ObstacleMap;
-    /**
-     * Shrink bbox to exclude the area around the anchor point
-     * This allows paths to start/end at the anchor but prevents crossing the node
-     */
-    private shrinkBBoxAroundAnchor;
-    /**
-     * Check if a point is accessible (not inside any obstacle)
-     * Uses binary search optimization: step -> step/2 -> step/4 -> ... -> 1px
-     */
-    isAccessible(point: Point, checkRadius?: number): boolean;
-    /**
-     * Check accessibility using binary search optimization
-     * Tries step -> step/2 -> step/4 -> ... -> 1px
-     */
-    private isAccessibleWithBinarySearch;
-}
-//# sourceMappingURL=ObstacleMap.d.ts.map

package/cjs/obstacle/ObstacleMap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObstacleMap.d.ts","sourceRoot":"","sources":["../../src/obstacle/ObstacleMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG7D;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,YAAY,CAAC,CAAO;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAO;gBAEhB,OAAO,EAAE,eAAe;IAMpC;;OAEG;IACH,KAAK,CACH,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,KAAK,EACpB,YAAY,CAAC,EAAE,KAAK,GACnB,WAAW;IAiEd;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA6D9B;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,MAAU,GAAG,OAAO;IAiD5D;;;OAGG;IACH,OAAO,CAAC,4BAA4B;CAqCrC"}