@mappedin/events 6.0.1-beta.58 → 6.6.0-beta.0

package/lib/esm/index.d.ts

@@ -4097,17 +4097,49 @@ type DirectionProperties = {
 };
 type DirectionFeature = Feature$1<Point$1, DirectionProperties>;
 type DirectionsCollection = FeatureCollection$1<Point$1, DirectionProperties>;
-type SimplifyDirectionsOptions = {
+interface DoorGeometry {
+	geoJSON: {
+		geometry: {
+			coordinates: [
+				[
+					number,
+					number
+				],
+				[
+					number,
+					number
+				]
+			];
+		};
+	};
+}
+type BaseSimplifyOptions = {
 	/**
 	 * Enable or disable simplifying.
 	 */
 	enabled: boolean;
 	/**
 	 * The radius of the buffer around the path to consider when simplifying, in meters.
-	 * @default 0.7
+	 * @default 0.4
 	 */
-	bufferRadius?: number;
+	radius?: number;
+};
+type GreedyLosOptions = BaseSimplifyOptions & {
+	__EXPERIMENTAL_METHOD?: "greedy-los";
 };
+type RdpOptions = BaseSimplifyOptions & {
+	__EXPERIMENTAL_METHOD: "rdp";
+};
+type DpOptimalOptions = BaseSimplifyOptions & {
+	__EXPERIMENTAL_METHOD: "dp-optimal";
+	/**
+	 * Whether to include door buffer nodes in DP simplification.
+	 * When true, predecessor and successor nodes of doors are marked with preventSmoothing.
+	 * @default false
+	 */
+	includeDoorBufferNodes?: boolean;
+};
+type SimplifyDirectionsOptions = GreedyLosOptions | RdpOptions | DpOptimalOptions;
 type DirectionsZone = {
 	geometry: Feature$1<MultiPolygon$1 | Polygon$1>;
 	/**
@@ -4125,6 +4157,7 @@ declare class Navigator$1 {
 	graph: NavigationGraph;
 	private geometryEdgesByMapId;
 	private flagDeclarations;
+	private getDoorByNodeId;
 	private disabledNodeIds;
 	/**
 	 * Constructs a Navigator instance to manage pathfinding with optional obstructions and grouping features.
@@ -4133,13 +4166,15 @@ declare class Navigator$1 {
 	 * @param {ObstructionCollection} [obstructions] - Optional collection of obstructions that could block paths.
 	 * @param {SpaceCollection} [spaces] - Optional collection of spaces that could block paths.
 	 * @param {string} [groupBy] - Optional property name to group nodes and paths for differentiated processing.
+	 * @param {Function} getDoorByNodeId - Function to get door object by node ID.
 	 */
-	constructor({ nodes, geojsonCollection, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, }: {
+	constructor({ nodes, geojsonCollection, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, getDoorByNodeId, }: {
 		nodes: NodeCollection$1;
 		geojsonCollection?: ObstructionCollection | SpaceCollection;
 		groupBy?: string;
 		multiplicativeDistanceWeightScaling?: boolean;
 		flagDeclarations?: NavigationFlagDeclarations;
+		getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
 	});
 	private getDisabledNodeIds;
 	/**
@@ -4152,9 +4187,11 @@ declare class Navigator$1 {
 	 * @param {SimplifyDirectionsOptions} [simplify] - Options to simplify the pathfinding result.
 	 * @returns {DirectionsCollection} A collection of directional features representing the path.
 	 */
-	getDirections({ zones: directionsZones, originIds, destinationNodeIds, disabledConnectionNodeIds, simplify, multiplicativeDistanceWeightScaling, overrideEdgeWeights, }: {
+	getDirections({ zones: directionsZones, originIds, from, to, destinationNodeIds, disabledConnectionNodeIds, simplify, multiplicativeDistanceWeightScaling, overrideEdgeWeights, }: {
 		originIds: string[];
 		destinationNodeIds: string[];
+		from: NodeFeature[];
+		to: NodeFeature[];
 		zones?: DirectionsZone[];
 		disabledConnectionNodeIds?: string[];
 		simplify?: SimplifyDirectionsOptions;
@@ -4169,11 +4206,21 @@ declare class Navigator$1 {
 	 */
 	private generatePath;
 	/**
-	 * Simplifies a sequence of steps by reducing unnecessary nodes using a buffer radius to check for obstructions.
+	 * Simplifies a sequence of steps by reducing unnecessary nodes using line-of-sight checks.
+	 *
+	 * Method Selection:
+	 * - 'greedy-los': Greedy forward scan with line-of-sight validation. Fastest, O(n) time complexity. Good default choice.
+	 * - 'rdp': Uses Ramer-Douglas-Peucker preprocessing + line-of-sight validation + door buffer nodes.
+	 *   Better for paths with doors and complex geometry. Medium speed.
+	 * - 'dp-optimal': Dynamic Programming for globally optimal simplification. Slowest but highest quality, O(n²) complexity.
+	 *   Best when path quality is critical (e.g., indoor navigation with many turns).
+	 *
+	 * Performance: greedy-los < rdp < dp-optimal
+	 * Quality: greedy-los < rdp < dp-optimal
 	 *
 	 * @param {Edge[]} steps - The steps to simplify.
-	 * @param {number} bufferRadius - The buffer radius to use
-	 * for simplification.
+	 * @param {SimplifyDirectionsOptions} options - Simplification options.
+	 * @param {boolean} multiplicativeDistanceWeightScaling - Distance weight scaling option.
 	 * @returns {Edge[]} An array of simplified edges representing a more direct path.
 	 */
 	private simplifyAllSteps;
@@ -4216,6 +4263,8 @@ declare class Navigator$1 {
 	 * @returns {Edge[]} An array of simplified edges.
 	 */
 	private simplifySteps;
+	private simplifyStepsImprovedWithSimplifyBeforeLoSChecks;
+	private simplifyStepsWithDPMethod;
 	/**
 	 * Calculates the approximate distance between two geographic coordinates on Earth's surface.
 	 *
@@ -4297,13 +4346,14 @@ declare class DirectionsInternal {
 	/**
 	 * @hidden
 	 */
-	constructor({ nodes, geojsonCollection, connections, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, }: {
+	constructor({ nodes, geojsonCollection, connections, groupBy, multiplicativeDistanceWeightScaling, flagDeclarations, getDoorByNodeId, }: {
 		nodes: ParsedMVF["node.geojson"];
 		geojsonCollection: ParsedMVF["obstruction"] | ParsedMVF["space"];
 		connections: ParsedMVF["connection.json"];
 		groupBy?: string;
 		multiplicativeDistanceWeightScaling?: boolean;
 		flagDeclarations?: ParsedMVF["navigationFlags.json"];
+		getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
 	});
 	processTargets(fromNodesByTarget: Map<TNavigationTarget, string[]>, toNodesByTarget: Map<TNavigationTarget, string[]>, mapData: MapDataInternal): {
 		originIds: string[];
@@ -4312,10 +4362,7 @@ declare class DirectionsInternal {
 	};
 	getDirections: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
 		accessible: boolean;
-		smoothing: {
-			enabled: boolean;
-			radius: number;
-		};
+		smoothing: SimplifyDirectionsOptions;
 		zones: TDirectionZone[];
 		excludedConnections: Connection[];
 		connectionIdWeightMap: Record<string, number>;
@@ -4323,10 +4370,7 @@ declare class DirectionsInternal {
 	/** @deprecated use getDirections instead */
 	getDirectionsSync: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
 		accessible: boolean;
-		smoothing: {
-			enabled: boolean;
-			radius: number;
-		};
+		smoothing: SimplifyDirectionsOptions;
 		zones: TDirectionZone[];
 		excludedConnections: Connection[];
 		connectionIdWeightMap: Record<string, number>;
@@ -4528,31 +4572,121 @@ type TGetDirectionsOptions = {
 	 */
 	accessible?: boolean;
 	/**
-	 * Enable or disable line-of-sight directions smoothing.
-	 * With this option enabled, the directions will be simplified to provide a more visually appealing path and shorter instructions.
+	 * Enable or disable path smoothing for directions.
+	 * When enabled, the path is simplified using line-of-sight checks to provide a more visually appealing route and shorter instructions.
+	 *
+	 * Can be a boolean to enable or disable smoothing, or an object with configuration options.
 	 *
-	 * Can be a boolean to enable or disable smoothing, or an object with a radius property to specify the line of sight radius in metres.
+	 * **Available methods:**
+	 * - `'greedy-los'` (default): Greedy forward scan with line-of-sight validation. Fastest, O(n) time complexity. Good default choice.
+	 * - `'rdp'`: Uses Ramer-Douglas-Peucker preprocessing + line-of-sight validation + door buffer nodes. Better for paths with doors and complex geometry. Medium speed.
+	 * - `'dp-optimal'`: Dynamic Programming for globally optimal simplification. Slowest but highest quality, O(n²) complexity. Best when path quality is critical.
 	 *
 	 * @default true for non-enterprise mode, false for enterprise mode
 	 *
 	 * @example
 	 * ```ts
-	 * // Enable smoothing with a radius of 3 metres
+	 * // Enable smoothing with default settings
 	 * mapView.getDirections(firstSpace, secondSpace, {
-	 * 	 smoothing: {
-	 *     radius: 3,
+	 *   smoothing: true
+	 * })
+	 *
+	 * // Enable smoothing with custom radius (in meters)
+	 * mapView.getDirections(firstSpace, secondSpace, {
+	 *   smoothing: {
+	 *     radius: 1.5,
 	 *   }
 	 * })
 	 *
-	 * // Explicitly enable smoothing in enterprise mode
+	 * // Use greedy line-of-sight method (default, explicit)
 	 * mapView.getDirections(firstSpace, secondSpace, {
-	 *   smoothing: true
+	 *   smoothing: {
+	 *     enabled: true,
+	 *     __EXPERIMENTAL_METHOD: 'greedy-los',
+	 *     radius: 0.4,
+	 *   }
+	 * })
+	 *
+	 * // Use RDP method (always uses line-of-sight)
+	 * mapView.getDirections(firstSpace, secondSpace, {
+	 *   smoothing: {
+	 *     enabled: true,
+	 *     __EXPERIMENTAL_METHOD: 'rdp',
+	 *     radius: 0.4,
+	 *   }
+	 * })
+	 *
+	 * // Use DP-optimal method with door buffer nodes
+	 * mapView.getDirections(firstSpace, secondSpace, {
+	 *   smoothing: {
+	 *     enabled: true,
+	 *     __EXPERIMENTAL_METHOD: 'dp-optimal',
+	 *     __EXPERIMENTAL_INCLUDE_DOOR_BUFFER_NODES: true,
+	 *     radius: 0.4,
+	 *   }
 	 * })
 	 * ```
 	 */
 	smoothing?: boolean | {
+		/**
+		 * Enable or disable path smoothing.
+		 * @default true for non-enterprise mode, false for enterprise mode
+		 */
+		enabled?: boolean;
+		/**
+		 * The radius of the buffer around the path to consider when simplifying, in meters.
+		 * @default 0.75
+		 */
+		radius?: number;
+		/**
+		 * @experimental
+		 * Path smoothing method using greedy line-of-sight algorithm.
+		 * Fastest method with O(n) time complexity. Good default choice.
+		 * @default 'greedy-los'
+		 */
+		__EXPERIMENTAL_METHOD?: "greedy-los";
+	} | {
+		/**
+		 * Enable or disable path smoothing.
+		 * @default true for non-enterprise mode, false for enterprise mode
+		 */
+		enabled?: boolean;
+		/**
+		 * The radius of the buffer around the path to consider when simplifying, in meters.
+		 * @default 0.75
+		 */
+		radius?: number;
+		/**
+		 * @experimental
+		 * Path smoothing method using Ramer-Douglas-Peucker preprocessing with line-of-sight validation.
+		 * Better for paths with doors and complex geometry. Medium speed.
+		 * Always uses line-of-sight validation (cannot be disabled).
+		 */
+		__EXPERIMENTAL_METHOD: "rdp";
+	} | {
+		/**
+		 * Enable or disable path smoothing.
+		 * @default true for non-enterprise mode, false for enterprise mode
+		 */
 		enabled?: boolean;
-		radius: number;
+		/**
+		 * The radius of the buffer around the path to consider when simplifying, in meters.
+		 * @default 0.75
+		 */
+		radius?: number;
+		/**
+		 * @experimental
+		 * Path smoothing method using Dynamic Programming for globally optimal simplification.
+		 * Slowest but highest quality, O(n²) complexity. Best when path quality is critical.
+		 */
+		__EXPERIMENTAL_METHOD: "dp-optimal";
+		/**
+		 * @experimental
+		 * Whether to include 0.5m buffer nodes perpendicular to doors in DP simplification.
+		 * When true, predecessor and successor nodes of doors are marked with preventSmoothing.
+		 * @default false
+		 */
+		__EXPERIMENTAL_INCLUDE_DOOR_BUFFER_NODES?: boolean;
 	};
 	/**
 	 * Defines the special zones for navigation operations.
@@ -5481,8 +5615,7 @@ declare class Connection extends DetailedMapData<Feature<Point, SpaceProperties>
 	 * @internal
 	 */
 	constructor(data: MapDataInternal, options: {
-		mvfDataByFloorId: Record<string, FeatureCollection<Point, SpaceProperties>["features"][number]> | Record<string, Feature<Point, MVFConnection>>;
-		accessible?: boolean;
+		mvfData: MVFConnection;
 	});
 	/**
 	 * Whether the connection is accessible. For example elevators are accessible while stairs are not.
@@ -5518,10 +5651,6 @@ declare class Connection extends DetailedMapData<Feature<Point, SpaceProperties>
 	 * @returns {Floor[]} An array of floors for the connection.
 	 */
 	get floors(): Floor[];
-	/**
-	 * Gets the location profiles ({@link LocationProfile}) associated with the connection.
-	 */
-	get locationProfiles(): LocationProfile[];
 	/** @internal */
 	get focusTarget(): Coordinate[];
 	/**
@@ -6150,8 +6279,6 @@ type MapDataRecords = {
 	locationProfilesByExternalId: Record<string, LocationProfile[]>;
 	objectEntranceNodeIdsByObstructionId: Record<string, string[]>;
 	obstructionIdByEntranceId: Record<string, string>;
-	connectionIdsByLatLon: Record<string, string[]>;
-	mvfConnectionIdsByLatLon: Record<string, string[]>;
 	locationProfilesByAttachedFeatureId: Record<string, LocationProfile[]>;
 	mvfSpacesById: Record<string, SpaceCollection["features"][number]>;
 	mvfNodesById: Record<string, NodeCollection["features"][number]>;
@@ -6740,7 +6867,6 @@ declare class MapDataInternal extends PubSub<{
 	mvfAnnotationsById: MapDataRecords["mvfAnnotationsById"];
 	mvfConnectionsById: MapDataRecords["mvfConnectionsById"];
 	mvfConnectionsByNodeId: MapDataRecords["mvfConnectionsByNodeId"];
-	mvfConnectionIdsByLatLon: MapDataRecords["mvfConnectionIdsByLatLon"];
 	mvfEntrancesById: MapDataRecords["mvfEntrancesById"];
 	mvfNodesById: MapDataRecords["mvfNodesById"];
 	mvfObstructionById: MapDataRecords["mvfObstructionById"];
@@ -6756,7 +6882,6 @@ declare class MapDataInternal extends PubSub<{
 	floorStacksByExternalId: MapDataRecords["floorStacksByExternalId"];
 	doorsByExternalId: MapDataRecords["doorsByExternalId"];
 	areasByExternalId: MapDataRecords["areasByExternalId"];
-	connectionSpaceIdsByLatLon: MapDataRecords["connectionIdsByLatLon"];
 	locationProfilesByAttachedFeatureId: MapDataRecords["locationProfilesByAttachedFeatureId"];
 	entranceNodeIdsBySpaceId?: MapDataRecords["entranceNodeIdsBySpaceId"];
 	locationsById: EnterpriseMapDataRecords["locationsById"];
@@ -6955,6 +7080,13 @@ declare class MapDataInternal extends PubSub<{
 	getDirections: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | TNavigationTarget[], opt?: TGetDirectionsOptions) => Promise<Directions | undefined>;
 	getDirectionsMultiDestination: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | (TNavigationTarget | TNavigationTarget[])[], opt?: TGetDirectionsOptions) => Promise<Directions[] | undefined>;
 	getDistance(from: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node$1 | EnterpriseLocation | Area, to: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node$1 | EnterpriseLocation | Area): number;
+	/**
+	 * Gets the door associated with a node.
+	 *
+	 * @param nodeId The ID of the node to check
+	 * @returns The door object if the node is associated with a door, undefined otherwise
+	 */
+	getDoorByNodeId: (nodeId: string) => Door | undefined;
 	transformImageRequest: (url: string) => Promise<{
 		url: string;
 	}>;