@mappedin/events 6.7.0-beta.0 → 6.8.0-beta.0

package/lib/esm/index.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationCollection, AnnotationSymbol, AreaCollection, AreaId, Category as MVFCategory, CategoryId, Connection as MVFConnection, Details, EnterpriseCategory as MVFEnterpriseCategory, EnterpriseCategory as MvfEnterpriseCategory, EnterpriseCategoryId as MVFEnterpriseCategoryId, EnterpriseLocation as MVFEnterpriseLocation, EnterpriseLocation as MvfEnterpriseLocation, EnterpriseLocationId as MVFEnterpriseLocationId, EnterpriseLocationInstance, EnterpriseVenue as MVFEnterpriseVenue, EnterpriseVenueType, EntranceCollection, EntranceFeature, Facade as MVFFacade, Feature, Feature as MVFFeature, FeatureCollection, FloorCollection, FloorProperties as MVFFloor, FloorProperties as MvfFloor, FloorStack as MVFFloorStack, FloorStack as MvfFloorStack, Geometry, Hyperlink as MVFHyperlink, Image as MVFImage, Language, LineStringStyle as TMVFLineStringStyle, Location as MVFLocation, LocationId, LocationLink, LocationSocial, LocationState, MultiPolygon, NavigationFlagDeclarations, NodeCollection, NodeCollection as MVFNodeCollection, NodeId, ObstructionCollection, ObstructionFeature, ObstructionId, ObstructionProperties, OpeningHoursSpecification, OperationHours, ParsedMVF, ParsedMVF as TMVF, ParsedMVFLocalePack, Point, PointStyle as TMVFPointStyle, Polygon, PolygonStyle as TMVFPolygonStyle, SiblingGroup, SpaceCollection, SpaceFeature, SpaceId, SpaceProperties, Style as TMVFStyle, StyleCollection as TMVFStyleCollection, TilesetStyle } from '@mappedin/mvf-v2';
+import { AnnotationCollection, AnnotationSymbol, AreaCollection, AreaId, Category as MVFCategory, CategoryId, Connection as MVFConnection, Details, EnterpriseCategory as MVFEnterpriseCategory, EnterpriseCategory as MvfEnterpriseCategory, EnterpriseCategoryId as MVFEnterpriseCategoryId, EnterpriseLocation as MVFEnterpriseLocation, EnterpriseLocation as MvfEnterpriseLocation, EnterpriseLocationId as MVFEnterpriseLocationId, EnterpriseLocationInstance, EnterpriseVenue as MVFEnterpriseVenue, EnterpriseVenueType, EntranceCollection, EntranceFeature, Facade as MVFFacade, Feature, Feature as MVFFeature, FeatureCollection, FloorCollection, FloorProperties as MVFFloor, FloorProperties as MvfFloor, FloorStack as MVFFloorStack, FloorStack as MvfFloorStack, Geometry, Hyperlink as MVFHyperlink, Image as MVFImage, Language, LineStringStyle as TMVFLineStringStyle, Location as MVF2Location, LocationId, LocationLink, LocationSocial, LocationState, MultiPolygon, NavigationFlagDeclarations, NodeCollection, NodeCollection as MVFNodeCollection, NodeId, ObstructionCollection, ObstructionFeature, ObstructionId, ObstructionProperties, OpeningHoursSpecification, OperationHours, ParsedMVF, ParsedMVF as TMVF, ParsedMVFLocalePack, ParsedMVFv3, Point, PointStyle as TMVFPointStyle, Polygon, PolygonStyle as TMVFPolygonStyle, SiblingGroup, SpaceCollection, SpaceFeature, SpaceId, SpaceProperties, Style as TMVFStyle, StyleCollection as TMVFStyleCollection, TilesetStyle } from '@mappedin/mvf-v2';
 import { ParsedMVF } from '@mappedin/mvf-v2/no-validator';
 
 declare const VALID_CONTEXTS: readonly [
@@ -4016,7 +4016,6 @@ type NodeProperties = {
 	 * */
 	[name: string]: any;
 };
-type NodeCollection$1 = FeatureCollection$1<Point$1, NodeProperties>;
 type NodeFeature = Feature$1<Point$1, NodeProperties>;
 declare class Edge {
 	/** The originating node of the edge */
@@ -4046,64 +4045,6 @@ declare class Edge {
 		multiplicativeDistanceWeightScaling?: boolean;
 	});
 }
-declare class NavigationGraph {
-	#private;
-	readonly edges: {
-		[propName: string]: Edge[];
-	};
-	readonly nodesById: {
-		[propName: string]: NodeFeature;
-	};
-	readonly nodesByGroup: Map<string, NodeFeature[]>;
-	constructor({ nodes, groupBy, multiplicativeDistanceWeightScaling, }: {
-		nodes: NodeCollection$1;
-		groupBy: string;
-		multiplicativeDistanceWeightScaling?: boolean;
-	});
-	/**
-	 * Calculates the shortest Euclidean distance from the origin node to any of the destination nodes.
-	 *
-	 * @param origin - The origin node.
-	 * @param destinations - An array of destination nodes.
-	 * @returns The shortest Euclidean distance.
-	 */
-	getShortestEuclideanDistance(origin: NodeFeature, destinations: NodeFeature[]): number;
-	hasLineOfSight: (origin: Position, destination: Position, edges?: Position[][], bufferRadius?: number) => boolean;
-	/**
-	 * Performs a Dijkstra search to find nodes within a given travel distance that satisfy a goal function, sorted by distance.
-	 *
-	 * @param originId - Origin node ID.
-	 * @param maxTravelDistance - The maximum travel distance.
-	 * @param includedNodeIds - Array of node IDs to include in the search.
-	 * @param obstructionEdges - Array of obstruction edges for line of sight calculations.
-	 * @param useLineOfSight - Whether to use line of sight checking.
-	 * @returns An Array of nodes within the travel distance that satisfy the goal function.
-	 * - feature: The node feature.
-	 * - distance: The distance to the node.
-	 * - edges: The edges to the node.
-	 */
-	dijkstraFindWithinTravelDistance(originId: string, maxTravelDistance: number, includedNodeIds: string[], obstructionEdges: Position[][], useLineOfSight: boolean, limitNumberOfResults: number): {
-		feature: NodeFeature;
-		distance: number;
-	}[];
-	/**
-	 * Performs A* pathfinding from specified origins to destinations, considering optional constraints like accessibility.
-	 *
-	 * @param {string[]} originIds - Array of origin node IDs.
-	 * @param {string[]} destinationNodeIds - Array of destination node IDs.
-	 * @param {Set<string>} [disabledConnectionNodeIds] - Optional set of connection node IDs that are disabled (ie. act as regular nodes).
-	 * @param {Set<string>} [disabledNodeIds] - Optional set of node IDs which are ignored during pathfinding.
-	 * @returns {Edge[]} An array of edges representing the shortest path, or an empty array if no path is found.
-	 */
-	aStar({ originIds, destinationNodeIds, disabledConnectionNodeIds, zones, overrideEdgeWeights, disabledNodeIds, }: {
-		originIds: string[];
-		destinationNodeIds: string[];
-		zones: DirectionsZone[];
-		disabledConnectionNodeIds?: Set<string>;
-		overrideEdgeWeights?: Map<Edge, number>;
-		disabledNodeIds?: Set<string>;
-	}): Edge[];
-}
 type DirectionProperties = {
 	/**
 	 * Unique identifier for the direction.
@@ -4127,204 +4068,6 @@ type DirectionProperties = {
 };
 type DirectionFeature = Feature$1<Point$1, DirectionProperties>;
 type DirectionsCollection = FeatureCollection$1<Point$1, DirectionProperties>;
-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.4
-	 */
-	radius?: number;
-};
-type GreedyLosOptions = BaseSimplifyOptions & {
-	__EXPERIMENTAL_METHOD?: "greedy-los";
-};
-type RdpOptions = BaseSimplifyOptions & {
-	__EXPERIMENTAL_METHOD: "rdp";
-	/**
-	 * Whether to include door-adjacent nodes (predecessor/successor of doors) in the must-include set.
-	 * When true, nodes immediately before and after doors are preserved during simplification.
-	 * @default true
-	 */
-	mustIncludeDoorBufferNodes?: boolean;
-};
-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>;
-	/**
-	 * The additional cost for navigation through the zone.
-	 */
-	cost: number;
-	/**
-	 *
-	 *  Additional property specific to the navigator based on the 'groupBy' option.
-	 */
-	[index: string]: any;
-};
-declare class Navigator$1 {
-	private groupBy;
-	graph: NavigationGraph;
-	private geometryEdgesByMapId;
-	private flagDeclarations;
-	private getDoorByNodeId;
-	private disabledNodeIds;
-	/**
-	 * Constructs a Navigator instance to manage pathfinding with optional obstructions and grouping features.
-	 *
-	 * @param {NodeCollection} nodes - Collection of nodes for the navigation graph.
-	 * @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, getDoorByNodeId, }: {
-		nodes: NodeCollection$1;
-		geojsonCollection?: ObstructionCollection | SpaceCollection;
-		groupBy?: string;
-		multiplicativeDistanceWeightScaling?: boolean;
-		flagDeclarations?: NavigationFlagDeclarations;
-		getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
-	});
-	private getDisabledNodeIds;
-	/**
-	 * Calculates and returns a set of directions from origin nodes to destination nodes, including detailed properties.
-	 *
-	 * @param {DirectionsZone[]} zones - special zones for navigation operations.
-	 * @param {string[]} originIds - IDs of origin nodes.
-	 * @param {string[]} destinationNodeIds - IDs of destination nodes.
-	 * @param {string[]} [disabledConnectionNodeIds] - IDs of connection nodes that are disabled (ie. act as regular nodes).
-	 * @param {SimplifyDirectionsOptions} [simplify] - Options to simplify the pathfinding result.
-	 * @returns {DirectionsCollection} A collection of directional features representing the path.
-	 */
-	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;
-		multiplicativeDistanceWeightScaling?: boolean;
-		overrideEdgeWeights?: Map<Edge, number>;
-	}): DirectionsCollection;
-	/**
-	 * Generates a path from a series of edges, constructing a feature collection of directional steps.
-	 *
-	 * @param {Edge[]} steps - An array of edges representing the path.
-	 * @returns {DirectionsCollection} A collection of directional features.
-	 */
-	private generatePath;
-	/**
-	 * 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 {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;
-	/**
-	 * Finds the nearest nodes on the graph within a given travel distance.
-	 *
-	 * @param originId - The ID of the origin node.
-	 * @param maxDistance - The maximum distance to search.
-	 * @param floorId - The ID of the floor.
-	 * @param includedNodeIds - The IDs of the nodes to include.
-	 * @param useLineOfSight - Whether to use line of sight.
-	 * @returns An array of nodes within the travel distance that satisfy the goal function.
-	 */
-	findNearestNodesOnGraph: (originId: string, maxDistance: number, floorId: string, includedNodeIds: string[], useLineOfSight?: boolean, limitNumberOfResults?: number) => {
-		feature: NodeFeature;
-		distance: number;
-	}[];
-	/**
-	 * Checks if there is a line of sight between two points on the map.
-	 *
-	 * @param origin - The origin point.
-	 * @param destination - The destination point.
-	 * @param floorId - The ID of the floor.
-	 * @param bufferRadius - The buffer radius to use when checking for line of sight.
-	 * @returns True if there is a line of sight, false otherwise.
-	 */
-	hasLineOfSight: (origin: [
-		number,
-		number
-	], destination: [
-		number,
-		number
-	], floorId: string, bufferRadius?: number) => boolean;
-	/**
-	 * Simplifies a section of steps by checking direct lines of sight between steps and eliminating intermediate nodes if unobstructed.
-	 *
-	 * @param {Edge[]} steps - The steps to potentially simplify.
-	 * @param {[number, number][][]} geometryEdges - The geometrical edges of the map used to check for line of sight.
-	 * @param {number} bufferRadius - The buffer radius to use when simplifying.
-	 * @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.
-	 *
-	 * This function uses the equirectangular approximation method to compute the distance, which simplifies
-	 * the math and speeds up calculations, but is less accurate over long distances compared to other methods
-	 * like the haversine formula.
-	 *
-	 * @param {Position} point1 - The first point's longitude and latitude as [longitude, latitude].
-	 * @param {Position} point2 - The second point's longitude and latitude as [longitude, latitude].
-	 * @return
-	 * @return {number} The approximate distance between the two points in meters.
-	 */
-	getDistance: (point1: Position, point2: Position) => number;
-	/**
-	 * Calculates the angle between two geographic coordinates.
-	 *
-	 * @param {Position} point1 - The first point's longitude and latitude as [longitude, latitude].
-	 * @param {Position} point2 - The second point's longitude and latitude as [longitude, latitude].
-	 * @hidden
-	 *
-	 * @return {number} The angle in radians, calculated clockwise from the north between the two points specified.
-	 */
-	getAngle: (point1: Position, point2: Position) => number;
-}
 declare class Directions {
 	#private;
 	id: string;
@@ -4375,79 +4118,6 @@ declare class Directions {
 		instructions: TDirectionInstruction[];
 	};
 }
-declare class DirectionsInternal {
-	#private;
-	navigator: Navigator$1;
-	private readonly connections;
-	/**
-	 * @hidden
-	 */
-	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[];
-		destinationNodeIds: string[];
-		featureToNodeIdsMap: Map<TNavigationTarget, string[]>;
-	};
-	getDirections: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
-		accessible: boolean;
-		smoothing: SimplifyDirectionsOptions;
-		zones: TDirectionZone[];
-		excludedConnections: Connection[];
-		connectionIdWeightMap: Record<string, number>;
-	}, mapData: MapDataInternal) => Promise<Directions | undefined>;
-	/** @deprecated use getDirections instead */
-	getDirectionsSync: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
-		accessible: boolean;
-		smoothing: SimplifyDirectionsOptions;
-		zones: TDirectionZone[];
-		excludedConnections: Connection[];
-		connectionIdWeightMap: Record<string, number>;
-	}, mapData: MapDataInternal) => Directions | undefined;
-	/**
-	 * Get the node IDs of connections that do not match the accessibility setting provided.
-	 * A disabled connection node is a connection node that acts as a regular node
-	 * (ie. the edges that would cause a floor change are ignored).
-	 *
-	 * @hidden
-	 * @param accessible {boolean}
-	 */
-	getDisabledConnectionNodeIds: (accessible: boolean) => string[];
-	/**
-	 * If the navigation targets are coordinates, make sure to include them in the final directions. For other
-	 * data types (e.g. POIs, Doors, Spaces), the coordinate should have a coincidental node generated in the
-	 * navigation graph already, so this is unnecessary.
-	 *
-	 * @hidden
-	 * @param directions
-	 * @param from {TNavigationTarget[]}
-	 * @param to {TNavigationTarget[]}
-	 */
-	private addCoordinateDirections;
-	/**
-	 * Create an geojson collection from the parsed MVF.
-	 *
-	 * @hidden
-	 * @param obstructions
-	 */
-	private createCollection;
-	/**
-	 * Create a direction feature.
-	 *
-	 * @hidden
-	 * @param coordinate
-	 * @param angle
-	 * @param distance
-	 */
-	private createDirectionFeature;
-}
 declare class Shape implements IFocusable {
 	/**
 	 * id of Shape
@@ -5020,7 +4690,8 @@ declare class ImageMetaData extends BaseMetaData {
 	 */
 	destroy(): void;
 }
-type LocationData = Omit<MVFLocation, "categories" | "spaces" | "obstructions" | "entrances" | "shapes" | "connections" | "annotations" | "areas" | "openingHoursSpecification" | "links" | "pictures" | "website" | "icon"> & {
+type MVF3Location = Required<ParsedMVFv3>["locations"][number];
+type LocationData = Omit<MVF2Location, "categories" | "spaces" | "obstructions" | "entrances" | "shapes" | "connections" | "annotations" | "areas" | "openingHoursSpecification" | "links" | "pictures" | "website" | "icon"> & {
 	links: Hyperlink[];
 	images: ImageMetaData[];
 	icon?: ImageMetaData;
@@ -5075,9 +4746,28 @@ declare class LocationProfile extends BaseMetaData implements LocationData, IFoc
 	 * @format uri
 	 */
 	icon?: ImageMetaData;
+	/**
+	 * Additional user defined data. The type is unknown, so it is recommended to validate the data before use.
+	 *
+	 * _Only available when loading MVFv3 data._
+	 *
+	 * ```ts
+	 * const mapData = await getMapData({
+	 *   ...
+	 *   mvfVersion: '3.0.0',
+	 * });
+	 *
+	 * const locationProfile = mapData.getById('location-profile', id);
+	 * if (typeof locationProfile?.extra?.myProperty === 'string') {
+	 * 	// Do something
+	 * }
+	 * ```
+	 */
+	extra?: Record<string, unknown>;
 	/** @internal */
 	constructor(data: MapDataInternal, options: {
-		mvfData: MVFLocation;
+		mvf2Data: MVF2Location;
+		mvf3Data?: MVF3Location;
 	});
 	/**
 	 * Gets the {@link Space}s associated with the location.
@@ -5921,6 +5611,7 @@ type TMapDataInternalOptions = {
 	binaryBundle?: Uint8Array;
 	tokenManager?: TokenManager;
 	getMapDataOptions?: TGetMapDataOptions;
+	mvf3?: ParsedMVFv3;
 };
 type MVFNodeFeature = MVFNodeCollection["features"][number];
 type MVFFloorFeature = FloorCollection["features"][number];
@@ -6348,6 +6039,7 @@ type MapDataRecords = {
 		[floorId: string]: AnnotationCollection["features"][number][];
 	};
 	mvfAreasById: Record<AreaId, AreaCollection["features"][number]>;
+	mvf3LocationsById: Record<string, Required<ParsedMVFv3>["locations"][number]>;
 };
 type EnterpriseMapDataRecords = {
 	connectionsByExternalId: Record<string, Connection[]>;