@rxflow/manhattan 0.0.2 → 0.0.3

package/cjs/utils/GlobalGrid.js

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultGlobalGrid = exports.GlobalGrid = void 0;
+var _geometry = require("../geometry");
+/**
+ * GlobalGrid class for consistent path alignment
+ * Feature: manhattan-optimization
+ *
+ * This class ensures all paths align to a unified global grid,
+ * solving the path overlap problem where paths should share segments.
+ */
+
+/**
+ * Global grid configuration
+ */
+
+/**
+ * GlobalGrid class for managing grid alignment
+ *
+ * Key features:
+ * - Uses a fixed global origin (0, 0) for consistent alignment across all paths
+ * - Supports configurable step sizes
+ * - Provides methods for snapping points to grid
+ * - Ensures path segments can properly overlap when they should
+ */
+class GlobalGrid {
+  /** Grid origin point */
+  origin;
+
+  /** Grid step size in X direction */
+  stepX;
+
+  /** Grid step size in Y direction */
+  stepY;
+  constructor(config) {
+    this.origin = config.origin ?? new _geometry.Point(0, 0);
+    this.stepX = config.stepX;
+    this.stepY = config.stepY;
+
+    // Validate step sizes
+    if (this.stepX <= 0 || this.stepY <= 0) {
+      throw new Error('Grid step sizes must be positive');
+    }
+  }
+
+  /**
+   * Create a GlobalGrid with uniform step size
+   */
+  static uniform(step, origin) {
+    return new GlobalGrid({
+      stepX: step,
+      stepY: step,
+      origin
+    });
+  }
+
+  /**
+   * Snap a single value to the grid
+   */
+  snapValue(value, step, originOffset = 0) {
+    const adjusted = value - originOffset;
+    const snapped = Math.round(adjusted / step) * step;
+    return snapped + originOffset;
+  }
+
+  /**
+   * Snap a point to the global grid
+   */
+  snapToGrid(point) {
+    return new _geometry.Point(this.snapValue(point.x, this.stepX, this.origin.x), this.snapValue(point.y, this.stepY, this.origin.y));
+  }
+
+  /**
+   * Snap a point to grid and apply precision rounding
+   */
+  snapToGridWithPrecision(point, precision) {
+    return this.snapToGrid(point).round(precision);
+  }
+
+  /**
+   * Check if a point is on the grid (within tolerance)
+   */
+  isOnGrid(point, tolerance = 0.001) {
+    const snapped = this.snapToGrid(point);
+    return Math.abs(point.x - snapped.x) < tolerance && Math.abs(point.y - snapped.y) < tolerance;
+  }
+
+  /**
+   * Get the nearest grid point in a specific direction
+   */
+  getNearestGridPoint(point, direction) {
+    const adjustedX = point.x - this.origin.x;
+    const adjustedY = point.y - this.origin.y;
+    let snappedX;
+    let snappedY;
+    switch (direction) {
+      case 'up':
+        snappedX = Math.round(adjustedX / this.stepX) * this.stepX;
+        snappedY = Math.floor(adjustedY / this.stepY) * this.stepY;
+        break;
+      case 'down':
+        snappedX = Math.round(adjustedX / this.stepX) * this.stepX;
+        snappedY = Math.ceil(adjustedY / this.stepY) * this.stepY;
+        break;
+      case 'left':
+        snappedX = Math.floor(adjustedX / this.stepX) * this.stepX;
+        snappedY = Math.round(adjustedY / this.stepY) * this.stepY;
+        break;
+      case 'right':
+        snappedX = Math.ceil(adjustedX / this.stepX) * this.stepX;
+        snappedY = Math.round(adjustedY / this.stepY) * this.stepY;
+        break;
+      case 'nearest':
+      default:
+        snappedX = Math.round(adjustedX / this.stepX) * this.stepX;
+        snappedY = Math.round(adjustedY / this.stepY) * this.stepY;
+        break;
+    }
+    return new _geometry.Point(snappedX + this.origin.x, snappedY + this.origin.y);
+  }
+
+  /**
+   * Get all grid points within a rectangle
+   */
+  getGridPointsInRect(minX, minY, maxX, maxY) {
+    const points = [];
+
+    // Snap bounds to grid
+    const startX = this.snapValue(minX, this.stepX, this.origin.x);
+    const startY = this.snapValue(minY, this.stepY, this.origin.y);
+    const endX = this.snapValue(maxX, this.stepX, this.origin.x);
+    const endY = this.snapValue(maxY, this.stepY, this.origin.y);
+    for (let x = startX; x <= endX; x += this.stepX) {
+      for (let y = startY; y <= endY; y += this.stepY) {
+        points.push(new _geometry.Point(x, y));
+      }
+    }
+    return points;
+  }
+
+  /**
+   * Calculate the grid distance between two points
+   * (number of grid steps, not actual distance)
+   */
+  gridDistance(p1, p2) {
+    const dx = Math.abs(p2.x - p1.x) / this.stepX;
+    const dy = Math.abs(p2.y - p1.y) / this.stepY;
+    return {
+      x: Math.round(dx),
+      y: Math.round(dy),
+      total: Math.round(dx) + Math.round(dy)
+    };
+  }
+
+  /**
+   * Snap an array of points to the grid
+   */
+  snapPathToGrid(points) {
+    return points.map(p => this.snapToGrid(p));
+  }
+
+  /**
+   * Snap path to grid and remove duplicate consecutive points
+   */
+  snapAndSimplifyPath(points, tolerance = 0.001) {
+    if (points.length === 0) return [];
+    const snapped = this.snapPathToGrid(points);
+    const simplified = [snapped[0]];
+    for (let i = 1; i < snapped.length; i++) {
+      const prev = simplified[simplified.length - 1];
+      const curr = snapped[i];
+
+      // Skip if same as previous point
+      if (Math.abs(prev.x - curr.x) < tolerance && Math.abs(prev.y - curr.y) < tolerance) {
+        continue;
+      }
+      simplified.push(curr);
+    }
+    return simplified;
+  }
+
+  /**
+   * Get grid offset for a direction
+   */
+  getDirectionOffset(direction) {
+    switch (direction) {
+      case 'up':
+        return new _geometry.Point(0, -this.stepY);
+      case 'down':
+        return new _geometry.Point(0, this.stepY);
+      case 'left':
+        return new _geometry.Point(-this.stepX, 0);
+      case 'right':
+        return new _geometry.Point(this.stepX, 0);
+    }
+  }
+
+  /**
+   * Clone this grid with optional overrides
+   */
+  clone(overrides) {
+    return new GlobalGrid({
+      stepX: overrides?.stepX ?? this.stepX,
+      stepY: overrides?.stepY ?? this.stepY,
+      origin: overrides?.origin ?? this.origin.clone()
+    });
+  }
+
+  /**
+   * Create a string representation for debugging
+   */
+  toString() {
+    return `GlobalGrid(origin: ${this.origin.toString()}, stepX: ${this.stepX}, stepY: ${this.stepY})`;
+  }
+}
+
+/**
+ * Default global grid instance with step size 10
+ */
+exports.GlobalGrid = GlobalGrid;
+const defaultGlobalGrid = exports.defaultGlobalGrid = GlobalGrid.uniform(10);

package/cjs/utils/PerformanceMonitor.d.ts

@@ -0,0 +1,139 @@
+/**
+ * PerformanceMonitor - 性能监控器
+ *
+ * 提供路径计算的性能监控和调试信息
+ * - 计时功能
+ * - 指标收集（迭代次数、查询次数等）
+ * - 指标导出和日志
+ *
+ * Feature: manhattan-optimization
+ * Requirements: 3.5, 5.5
+ */
+/**
+ * 性能指标接口
+ */
+export interface PerformanceMetrics {
+    /** 路径查找耗时（毫秒） */
+    pathfindingTime: number;
+    /** A* 迭代次数 */
+    iterations: number;
+    /** 障碍物查询次数 */
+    obstacleQueries: number;
+    /** 缓存命中率 */
+    cacheHitRate: number;
+    /** 路径点数量 */
+    pathPointCount: number;
+    /** 开始时间戳 */
+    startTime?: number;
+    /** 结束时间戳 */
+    endTime?: number;
+}
+/**
+ * 日志级别
+ */
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+/**
+ * 性能监控配置
+ */
+export interface PerformanceMonitorConfig {
+    /** 是否启用日志 */
+    enableLogging: boolean;
+    /** 是否启用指标收集 */
+    enableMetrics: boolean;
+    /** 日志级别 */
+    logLevel: LogLevel;
+}
+/**
+ * 默认性能监控配置
+ */
+export declare const DEFAULT_PERFORMANCE_MONITOR_CONFIG: PerformanceMonitorConfig;
+/**
+ * 性能监控器
+ */
+export declare class PerformanceMonitor {
+    private config;
+    private metrics;
+    private activeTimers;
+    private globalCounters;
+    constructor(config?: Partial<PerformanceMonitorConfig>);
+    /**
+     * 开始监控
+     */
+    startMonitoring(label: string): void;
+    /**
+     * 结束监控并记录
+     */
+    endMonitoring(label: string): PerformanceMetrics;
+    /**
+     * 记录迭代次数
+     */
+    recordIterations(label: string, count: number): void;
+    /**
+     * 增加障碍物查询计数
+     */
+    incrementObstacleQueries(label: string, count?: number): void;
+    /**
+     * 记录路径点数量
+     */
+    recordPathPointCount(label: string, count: number): void;
+    /**
+     * 记录缓存命中
+     */
+    recordCacheHit(): void;
+    /**
+     * 记录缓存未命中
+     */
+    recordCacheMiss(): void;
+    /**
+     * 计算缓存命中率
+     */
+    private calculateCacheHitRate;
+    /**
+     * 获取指定标签的指标
+     */
+    getMetrics(label: string): PerformanceMetrics | undefined;
+    /**
+     * 获取所有指标
+     */
+    getAllMetrics(): Map<string, PerformanceMetrics>;
+    /**
+     * 清除指标
+     */
+    clearMetrics(): void;
+    /**
+     * 导出为日志字符串
+     */
+    exportToLog(): string;
+    /**
+     * 获取摘要统计
+     */
+    getSummary(): {
+        totalTime: number;
+        avgTime: number;
+        maxTime: number;
+        minTime: number;
+        totalIterations: number;
+        cacheHitRate: number;
+    };
+    /**
+     * 内部日志方法
+     */
+    private log;
+    /**
+     * 更新配置
+     */
+    updateConfig(config: Partial<PerformanceMonitorConfig>): void;
+    /**
+     * 获取当前配置
+     */
+    getConfig(): PerformanceMonitorConfig;
+}
+/**
+ * 获取全局性能监控器
+ */
+export declare function getGlobalPerformanceMonitor(): PerformanceMonitor;
+/**
+ * 重置全局性能监控器
+ */
+export declare function resetGlobalPerformanceMonitor(): void;
+//# sourceMappingURL=PerformanceMonitor.d.ts.map

package/cjs/utils/PerformanceMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceMonitor.d.ts","sourceRoot":"","sources":["../../src/utils/PerformanceMonitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iBAAiB;IACjB,eAAe,EAAE,MAAM,CAAA;IACvB,cAAc;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc;IACd,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY;IACZ,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAE1D;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,aAAa;IACb,aAAa,EAAE,OAAO,CAAA;IACtB,eAAe;IACf,aAAa,EAAE,OAAO,CAAA;IACtB,WAAW;IACX,QAAQ,EAAE,QAAQ,CAAA;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,kCAAkC,EAAE,wBAIhD,CAAA;AAeD;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,OAAO,CAA6C;IAC5D,OAAO,CAAC,YAAY,CAAiC;IACrD,OAAO,CAAC,cAAc,CAMrB;gBAEW,MAAM,GAAE,OAAO,CAAC,wBAAwB,CAAM;IAO1D;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAepC;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB;IAsBhD;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IASpD;;OAEG;IACH,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,IAAI;IASxD;;OAEG;IACH,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IASxD;;OAEG;IACH,cAAc,IAAI,IAAI;IAMtB;;OAEG;IACH,eAAe,IAAI,IAAI;IAKvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIzD;;OAEG;IACH,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAIhD;;OAEG;IACH,YAAY,IAAI,IAAI;IASpB;;OAEG;IACH,WAAW,IAAI,MAAM;IAoBrB;;OAEG;IACH,UAAU,IAAI;QACZ,SAAS,EAAE,MAAM,CAAA;QACjB,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,EAAE,MAAM,CAAA;QACf,eAAe,EAAE,MAAM,CAAA;QACvB,YAAY,EAAE,MAAM,CAAA;KACrB;IAwBD;;OAEG;IACH,OAAO,CAAC,GAAG;IAyBX;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,wBAAwB,CAAC,GAAG,IAAI;IAI7D;;OAEG;IACH,SAAS,IAAI,wBAAwB;CAGtC;AAOD;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,kBAAkB,CAKhE;AAED;;GAEG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD"}

package/cjs/utils/PerformanceMonitor.js

@@ -0,0 +1,305 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PerformanceMonitor = exports.DEFAULT_PERFORMANCE_MONITOR_CONFIG = void 0;
+exports.getGlobalPerformanceMonitor = getGlobalPerformanceMonitor;
+exports.resetGlobalPerformanceMonitor = resetGlobalPerformanceMonitor;
+/**
+ * PerformanceMonitor - 性能监控器
+ *
+ * 提供路径计算的性能监控和调试信息
+ * - 计时功能
+ * - 指标收集（迭代次数、查询次数等）
+ * - 指标导出和日志
+ *
+ * Feature: manhattan-optimization
+ * Requirements: 3.5, 5.5
+ */
+
+/**
+ * 性能指标接口
+ */
+
+/**
+ * 日志级别
+ */
+
+/**
+ * 性能监控配置
+ */
+
+/**
+ * 默认性能监控配置
+ */
+const DEFAULT_PERFORMANCE_MONITOR_CONFIG = exports.DEFAULT_PERFORMANCE_MONITOR_CONFIG = {
+  enableLogging: false,
+  enableMetrics: false,
+  logLevel: 'info'
+};
+
+/**
+ * 创建空的性能指标
+ */
+function createEmptyMetrics() {
+  return {
+    pathfindingTime: 0,
+    iterations: 0,
+    obstacleQueries: 0,
+    cacheHitRate: 0,
+    pathPointCount: 0
+  };
+}
+
+/**
+ * 性能监控器
+ */
+class PerformanceMonitor {
+  config;
+  metrics = new Map();
+  activeTimers = new Map();
+  globalCounters = {
+    totalCacheHits: 0,
+    totalCacheQueries: 0
+  };
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_PERFORMANCE_MONITOR_CONFIG,
+      ...config
+    };
+  }
+
+  /**
+   * 开始监控
+   */
+  startMonitoring(label) {
+    if (!this.config.enableMetrics) return;
+    const startTime = performance.now();
+    this.activeTimers.set(label, startTime);
+
+    // 初始化指标
+    this.metrics.set(label, {
+      ...createEmptyMetrics(),
+      startTime
+    });
+    this.log('debug', `[PerformanceMonitor] Started monitoring: ${label}`);
+  }
+
+  /**
+   * 结束监控并记录
+   */
+  endMonitoring(label) {
+    const endTime = performance.now();
+    const startTime = this.activeTimers.get(label);
+    if (!startTime) {
+      this.log('warn', `[PerformanceMonitor] No active timer for: ${label}`);
+      return createEmptyMetrics();
+    }
+    const metrics = this.metrics.get(label) || createEmptyMetrics();
+    metrics.pathfindingTime = endTime - startTime;
+    metrics.endTime = endTime;
+    metrics.cacheHitRate = this.calculateCacheHitRate();
+    this.metrics.set(label, metrics);
+    this.activeTimers.delete(label);
+    this.log('info', `[PerformanceMonitor] ${label}: ${metrics.pathfindingTime.toFixed(2)}ms, ${metrics.iterations} iterations, ${metrics.pathPointCount} points`);
+    return metrics;
+  }
+
+  /**
+   * 记录迭代次数
+   */
+  recordIterations(label, count) {
+    if (!this.config.enableMetrics) return;
+    const metrics = this.metrics.get(label);
+    if (metrics) {
+      metrics.iterations = count;
+    }
+  }
+
+  /**
+   * 增加障碍物查询计数
+   */
+  incrementObstacleQueries(label, count = 1) {
+    if (!this.config.enableMetrics) return;
+    const metrics = this.metrics.get(label);
+    if (metrics) {
+      metrics.obstacleQueries += count;
+    }
+  }
+
+  /**
+   * 记录路径点数量
+   */
+  recordPathPointCount(label, count) {
+    if (!this.config.enableMetrics) return;
+    const metrics = this.metrics.get(label);
+    if (metrics) {
+      metrics.pathPointCount = count;
+    }
+  }
+
+  /**
+   * 记录缓存命中
+   */
+  recordCacheHit() {
+    if (!this.config.enableMetrics) return;
+    this.globalCounters.totalCacheHits++;
+    this.globalCounters.totalCacheQueries++;
+  }
+
+  /**
+   * 记录缓存未命中
+   */
+  recordCacheMiss() {
+    if (!this.config.enableMetrics) return;
+    this.globalCounters.totalCacheQueries++;
+  }
+
+  /**
+   * 计算缓存命中率
+   */
+  calculateCacheHitRate() {
+    if (this.globalCounters.totalCacheQueries === 0) return 0;
+    return this.globalCounters.totalCacheHits / this.globalCounters.totalCacheQueries;
+  }
+
+  /**
+   * 获取指定标签的指标
+   */
+  getMetrics(label) {
+    return this.metrics.get(label);
+  }
+
+  /**
+   * 获取所有指标
+   */
+  getAllMetrics() {
+    return new Map(this.metrics);
+  }
+
+  /**
+   * 清除指标
+   */
+  clearMetrics() {
+    this.metrics.clear();
+    this.activeTimers.clear();
+    this.globalCounters = {
+      totalCacheHits: 0,
+      totalCacheQueries: 0
+    };
+  }
+
+  /**
+   * 导出为日志字符串
+   */
+  exportToLog() {
+    const lines = ['=== Performance Metrics ==='];
+    for (const [label, metrics] of this.metrics) {
+      lines.push(`\n[${label}]`);
+      lines.push(`  Time: ${metrics.pathfindingTime.toFixed(2)}ms`);
+      lines.push(`  Iterations: ${metrics.iterations}`);
+      lines.push(`  Obstacle Queries: ${metrics.obstacleQueries}`);
+      lines.push(`  Path Points: ${metrics.pathPointCount}`);
+      lines.push(`  Cache Hit Rate: ${(metrics.cacheHitRate * 100).toFixed(1)}%`);
+    }
+    lines.push('\n=== Global Stats ===');
+    lines.push(`  Total Cache Queries: ${this.globalCounters.totalCacheQueries}`);
+    lines.push(`  Total Cache Hits: ${this.globalCounters.totalCacheHits}`);
+    lines.push(`  Overall Cache Hit Rate: ${(this.calculateCacheHitRate() * 100).toFixed(1)}%`);
+    return lines.join('\n');
+  }
+
+  /**
+   * 获取摘要统计
+   */
+  getSummary() {
+    let totalTime = 0;
+    let maxTime = 0;
+    let minTime = Infinity;
+    let totalIterations = 0;
+    for (const metrics of this.metrics.values()) {
+      totalTime += metrics.pathfindingTime;
+      maxTime = Math.max(maxTime, metrics.pathfindingTime);
+      minTime = Math.min(minTime, metrics.pathfindingTime);
+      totalIterations += metrics.iterations;
+    }
+    const count = this.metrics.size;
+    return {
+      totalTime,
+      avgTime: count > 0 ? totalTime / count : 0,
+      maxTime: count > 0 ? maxTime : 0,
+      minTime: count > 0 && minTime !== Infinity ? minTime : 0,
+      totalIterations,
+      cacheHitRate: this.calculateCacheHitRate()
+    };
+  }
+
+  /**
+   * 内部日志方法
+   */
+  log(level, message) {
+    if (!this.config.enableLogging) return;
+    const levels = ['error', 'warn', 'info', 'debug'];
+    const configLevelIndex = levels.indexOf(this.config.logLevel);
+    const messageLevelIndex = levels.indexOf(level);
+    if (messageLevelIndex <= configLevelIndex) {
+      switch (level) {
+        case 'error':
+          console.error(message);
+          break;
+        case 'warn':
+          console.warn(message);
+          break;
+        case 'info':
+          console.info(message);
+          break;
+        case 'debug':
+          console.debug(message);
+          break;
+      }
+    }
+  }
+
+  /**
+   * 更新配置
+   */
+  updateConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+  }
+
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+}
+
+/**
+ * 全局性能监控器实例（可选使用）
+ */
+exports.PerformanceMonitor = PerformanceMonitor;
+let globalMonitor = null;
+
+/**
+ * 获取全局性能监控器
+ */
+function getGlobalPerformanceMonitor() {
+  if (!globalMonitor) {
+    globalMonitor = new PerformanceMonitor();
+  }
+  return globalMonitor;
+}
+
+/**
+ * 重置全局性能监控器
+ */
+function resetGlobalPerformanceMonitor() {
+  globalMonitor = null;
+}

package/cjs/utils/direction.d.ts

@@ -0,0 +1,24 @@
+import { Point } from '../geometry';
+import type { ResolvedOptions } from '../options';
+import type { Grid } from './grid';
+/**
+ * Get direction angle from start point to end point
+ * Corrects for grid deformation between start and end
+ */
+export declare function getDirectionAngle(start: Point, end: Point, directionCount: number, grid: Grid, options: ResolvedOptions): number;
+/**
+ * Get the change in direction between two direction angles
+ */
+export declare function getDirectionChange(angle1: number, angle2: number): number;
+/**
+ * Fix direction offsets according to current grid
+ */
+export declare function getGridOffsets(grid: Grid, options: ResolvedOptions): {
+    cost: number;
+    offsetX: number;
+    offsetY: number;
+    angle?: number | undefined;
+    gridOffsetX?: number | undefined;
+    gridOffsetY?: number | undefined;
+}[];
+//# sourceMappingURL=direction.d.ts.map

package/cjs/utils/direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direction.d.ts","sourceRoot":"","sources":["../../src/utils/direction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAyBlC;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,KAAK,EACV,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,GACvB,MAAM,CAKR;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe;;;;;;;IASlE"}