venue-js 1.4.0-next.19 → 1.4.0-next.20

package/dist/index.js

@@ -69,6 +69,7 @@ __export(index_exports, {
   getLocationByFeature: () => getLocationByFeature,
   getLocationByOccupant: () => getLocationByOccupant,
   getLocationIdByFeature: () => getLocationIdByFeature,
+  getNavigateClient: () => getNavigateClient,
   getOrdinalByLocationId: () => getOrdinalByLocationId,
   getRelatedLocationIdsByFeature: () => getRelatedLocationIdsByFeature,
   getRelatedLocationsByAmenity: () => getRelatedLocationsByAmenity,
@@ -238,6 +239,119 @@ var defaultFeatureQueryOptionsMap = {
   model3d: {}
 };
 
+// src/data/utils/geometry-validator.ts
+var isValidCoordinate = (point2) => {
+  return point2.length === 2 && point2.every((coord) => typeof coord === "number");
+};
+function isValidLinearRingCoordinates(ring) {
+  if (ring.length < 4) {
+    return false;
+  }
+  return ring.every(isValidCoordinate) && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1];
+}
+var isValidPolygonCoordinates = (polygon2) => {
+  if (Array.isArray(polygon2[0]) && (polygon2[0].length === 0 || typeof polygon2[0][0] === "number")) {
+    return isValidLinearRingCoordinates(polygon2);
+  }
+  if (Array.isArray(polygon2) && polygon2.length > 0 && Array.isArray(polygon2[0])) {
+    if (!isValidLinearRingCoordinates(polygon2[0])) {
+      return false;
+    }
+    for (let i = 1; i < polygon2.length; i++) {
+      if (!isValidLinearRingCoordinates(polygon2[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+};
+var isValidMultiPolygonCoordinates = (multipolygon) => {
+  return multipolygon.every(isValidPolygonCoordinates);
+};
+var isValidLineStringCoordinates = (lineString2) => {
+  if (!Array.isArray(lineString2) || lineString2.length < 2) {
+    return false;
+  }
+  const firstPoint = lineString2[0];
+  const lastPoint = lineString2[lineString2.length - 1];
+  if (firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1]) {
+    return false;
+  }
+  return lineString2.every(isValidCoordinate);
+};
+var isValidMultiPolygon = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "MultiPolygon" && isValidMultiPolygonCoordinates(coordinates);
+};
+var isValidPolygon = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "Polygon" && isValidPolygonCoordinates(coordinates);
+};
+var isValidLineString = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "LineString" && isValidLineStringCoordinates(coordinates);
+};
+var isValidPoint = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "Point" && isValidCoordinate(coordinates);
+};
+
+// src/data/utils/match-filters.ts
+function isInFilter(filter) {
+  return typeof filter === "object" && filter !== null && "$in" in filter && Array.isArray(filter.$in);
+}
+var someIntersect = (a, b) => a.some((v) => b.includes(v));
+function matchFilter(value, filter) {
+  if (Array.isArray(value)) {
+    if (isInFilter(filter)) return someIntersect(value, filter.$in);
+    return value.includes(filter);
+  } else {
+    if (isInFilter(filter)) return filter.$in.includes(value);
+    return value === filter;
+  }
+}
+function matchFilters(item, filters) {
+  return Object.entries(filters).every(([key, filter]) => {
+    return matchFilter(item.properties[key], filter);
+  });
+}
+
+// src/data/utils/occupant-helper.ts
+var occupant_helper_exports = {};
+__export(occupant_helper_exports, {
+  getOccupantCorrelatedLocations: () => getOccupantCorrelatedLocations,
+  getOccupantMainLocation: () => getOccupantMainLocation,
+  getOccupantMarkerLocations: () => getOccupantMarkerLocations
+});
+
+// src/data/utils/lodash/compact.ts
+var compact = (arr) => arr.filter((item) => Boolean(item));
+
+// src/data/utils/occupant-helper.ts
+var getOccupantMainLocation = (occupant) => {
+  return occupant.properties.kiosk || occupant.properties.unit;
+};
+var getOccupantCorrelatedLocations = (occupant) => {
+  const allCorrelatedLocations = [
+    ...occupant.properties.units,
+    ...occupant.properties.kiosks
+  ];
+  return compact(allCorrelatedLocations);
+};
+var getOccupantMarkerLocations = (occupant, options) => {
+  const placementType = options?.type ? options.type : occupant.properties.show_name_on_all_units ? "ALL_LOCATIONS" : "ONCE_PER_LEVEL";
+  const mainLocation = getOccupantMainLocation(occupant);
+  const mainLocationLevel = mainLocation?.properties?.level_id;
+  const allCorrelatedLocations = getOccupantCorrelatedLocations(occupant);
+  if (placementType === "ALL_LOCATIONS") {
+    return compact([mainLocation, ...allCorrelatedLocations]);
+  }
+  const otherLevelLocations = allCorrelatedLocations.filter((f) => f.properties.level_id !== mainLocationLevel);
+  const onePerLevelLocations = [...new Map(otherLevelLocations.map((loc) => [loc.properties.level_id, loc])).values()];
+  return compact([mainLocation, ...onePerLevelLocations]);
+};
+
 // src/data/api/delivery-project.ts
 async function fetchDeliveryApi(projectId, apiKey, featureType, baseUrl = DEFAULT_BASE_URL) {
   switch (featureType) {
@@ -359,119 +473,6 @@ var safeFetchFeature = async (featureType, params) => {
   }
 };
 
-// src/data/utils/geometry-validator.ts
-var isValidCoordinate = (point2) => {
-  return point2.length === 2 && point2.every((coord) => typeof coord === "number");
-};
-function isValidLinearRingCoordinates(ring) {
-  if (ring.length < 4) {
-    return false;
-  }
-  return ring.every(isValidCoordinate) && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1];
-}
-var isValidPolygonCoordinates = (polygon2) => {
-  if (Array.isArray(polygon2[0]) && (polygon2[0].length === 0 || typeof polygon2[0][0] === "number")) {
-    return isValidLinearRingCoordinates(polygon2);
-  }
-  if (Array.isArray(polygon2) && polygon2.length > 0 && Array.isArray(polygon2[0])) {
-    if (!isValidLinearRingCoordinates(polygon2[0])) {
-      return false;
-    }
-    for (let i = 1; i < polygon2.length; i++) {
-      if (!isValidLinearRingCoordinates(polygon2[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-};
-var isValidMultiPolygonCoordinates = (multipolygon) => {
-  return multipolygon.every(isValidPolygonCoordinates);
-};
-var isValidLineStringCoordinates = (lineString2) => {
-  if (!Array.isArray(lineString2) || lineString2.length < 2) {
-    return false;
-  }
-  const firstPoint = lineString2[0];
-  const lastPoint = lineString2[lineString2.length - 1];
-  if (firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1]) {
-    return false;
-  }
-  return lineString2.every(isValidCoordinate);
-};
-var isValidMultiPolygon = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "MultiPolygon" && isValidMultiPolygonCoordinates(coordinates);
-};
-var isValidPolygon = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "Polygon" && isValidPolygonCoordinates(coordinates);
-};
-var isValidLineString = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "LineString" && isValidLineStringCoordinates(coordinates);
-};
-var isValidPoint = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "Point" && isValidCoordinate(coordinates);
-};
-
-// src/data/utils/match-filters.ts
-function isInFilter(filter) {
-  return typeof filter === "object" && filter !== null && "$in" in filter && Array.isArray(filter.$in);
-}
-var someIntersect = (a, b) => a.some((v) => b.includes(v));
-function matchFilter(value, filter) {
-  if (Array.isArray(value)) {
-    if (isInFilter(filter)) return someIntersect(value, filter.$in);
-    return value.includes(filter);
-  } else {
-    if (isInFilter(filter)) return filter.$in.includes(value);
-    return value === filter;
-  }
-}
-function matchFilters(item, filters) {
-  return Object.entries(filters).every(([key, filter]) => {
-    return matchFilter(item.properties[key], filter);
-  });
-}
-
-// src/data/utils/occupant-helper.ts
-var occupant_helper_exports = {};
-__export(occupant_helper_exports, {
-  getOccupantCorrelatedLocations: () => getOccupantCorrelatedLocations,
-  getOccupantMainLocation: () => getOccupantMainLocation,
-  getOccupantMarkerLocations: () => getOccupantMarkerLocations
-});
-
-// src/data/utils/lodash/compact.ts
-var compact = (arr) => arr.filter((item) => Boolean(item));
-
-// src/data/utils/occupant-helper.ts
-var getOccupantMainLocation = (occupant) => {
-  return occupant.properties.kiosk || occupant.properties.unit;
-};
-var getOccupantCorrelatedLocations = (occupant) => {
-  const allCorrelatedLocations = [
-    ...occupant.properties.units,
-    ...occupant.properties.kiosks
-  ];
-  return compact(allCorrelatedLocations);
-};
-var getOccupantMarkerLocations = (occupant, options) => {
-  const placementType = options?.type ? options.type : occupant.properties.show_name_on_all_units ? "ALL_LOCATIONS" : "ONCE_PER_LEVEL";
-  const mainLocation = getOccupantMainLocation(occupant);
-  const mainLocationLevel = mainLocation?.properties?.level_id;
-  const allCorrelatedLocations = getOccupantCorrelatedLocations(occupant);
-  if (placementType === "ALL_LOCATIONS") {
-    return compact([mainLocation, ...allCorrelatedLocations]);
-  }
-  const otherLevelLocations = allCorrelatedLocations.filter((f) => f.properties.level_id !== mainLocationLevel);
-  const onePerLevelLocations = [...new Map(otherLevelLocations.map((loc) => [loc.properties.level_id, loc])).values()];
-  return compact([mainLocation, ...onePerLevelLocations]);
-};
-
 // src/data/getDataClient.ts
 var import_query_core = require("@tanstack/query-core");
 
@@ -876,7 +877,7 @@ var getDistanceOptions = (options, category) => {
 
 // src/data/utils/trace.ts
 var trace = (namespace, text, ms, color) => {
-  console.log(`[${namespace}] %c${text.padEnd(90)}   ${ms !== void 0 ? `${ms.toFixed(1).padStart(6)} ms` : ``}`, color ? `color: ${color}` : void 0);
+  if (process.env.NODE_ENV !== "test") console.log(`[${namespace}] %c${text.padEnd(90)}   ${ms !== void 0 ? `${ms.toFixed(1).padStart(6)} ms` : ``}`, color ? `color: ${color}` : void 0);
 };
 
 // src/data/navigate/graph/nodemap/createTraversalNodeMap.ts
@@ -1287,7 +1288,6 @@ var prepareGraph = (options) => {
 // src/data/navigate/steps/createStepUtils.ts
 var import_lodash12 = require("lodash");
 var import_intersectionBy = __toESM(require("lodash/intersectionBy"));
-var import_center9 = require("@turf/center");
 
 // src/data/navigate/description/describe.ts
 var t = (template, locale, options) => {
@@ -1686,7 +1686,7 @@ function pruneSmallAngles(path, minDeg = 10) {
   if (path.length <= 2) return path;
   const out = [path[0]];
   for (let i = 1; i < path.length - 1; i++) {
-    const a = out[out.length - 1];
+    const a = out.at(-1);
     const b = path[i];
     const c = path[i + 1];
     const abx = b[0] - a[0], aby = b[1] - a[1];
@@ -1697,7 +1697,7 @@ function pruneSmallAngles(path, minDeg = 10) {
     const angle = Math.acos(dot / (ab * bc)) * 180 / Math.PI;
     if (angle > minDeg) out.push(b);
   }
-  out.push(path[path.length - 1]);
+  out.push(path.at(-1));
   return out;
 }
 
@@ -1705,7 +1705,7 @@ function pruneSmallAngles(path, minDeg = 10) {
 function pruneShortSegments(path, minLen = 5) {
   const out = [path[0]];
   for (let i = 1; i < path.length; i++) {
-    const [x0, y0] = out[out.length - 1];
+    const [x0, y0] = out.at(-1);
     const [x1, y1] = path[i];
     if (Math.hypot(x1 - x0, y1 - y0) >= minLen) {
       out.push(path[i]);
@@ -1907,7 +1907,7 @@ var shortestPath_default = shortestPath;
 // src/data/navigate/steps/path/index.ts
 var createStepPathUtils = (options) => {
   const resolution = options.resolution ?? 88e-5;
-  const { units, kiosks, fixtures } = options.data;
+  const { units = [], kiosks = [], fixtures = [] } = options.data;
   const possibleObstacleFeatures = [...units, ...kiosks, ...fixtures];
   const filterObstaclesByOrdinal = (levelId) => {
     return possibleObstacleFeatures.filter(({ feature_type, properties, geometry }) => {
@@ -1973,181 +1973,6 @@ var createStepPathUtils = (options) => {
   };
 };
 
-// src/data/navigate/landmark/createLandmarkUtils.ts
-var import_center6 = require("@turf/center");
-var import_distance5 = __toESM(require("@turf/distance"));
-var NEARBY_DISTANCE = 30;
-var createLandmarkUtils = (options) => {
-  const { data, findByIdSync } = options;
-  const { occupants } = data;
-  const occupantToLandmark = (occupant) => {
-    const locationType = occupant.properties.unit_id ? "unit" : "kiosk";
-    const locationId = locationType === "unit" ? occupant.properties.unit_id : occupant.properties.kiosk_id;
-    const location = locationType === "unit" ? findByIdSync(locationId) : findByIdSync(locationId);
-    const level = findByIdSync(location.properties.level_id);
-    return {
-      name: occupant.properties.name,
-      point: (0, import_center6.center)(location.geometry).geometry.coordinates,
-      level_id: location.properties.level_id,
-      is_priority: occupant.properties.is_landmark,
-      ordinal: level.properties.ordinal
-    };
-  };
-  const landmarks = [
-    ...occupants.map(occupantToLandmark)
-  ];
-  const findNearbyLandmarks = (point2, levelId) => {
-    if (point2 === null || levelId === null) return [];
-    return landmarks.map((landmark) => {
-      const landmarkAndDistance = {
-        landmark,
-        d: (0, import_distance5.default)(point2, landmark.point, { units: "meters" })
-      };
-      return landmarkAndDistance;
-    }).filter(({ landmark, d }) => d <= NEARBY_DISTANCE && landmark.level_id === levelId).sort((a, b) => {
-      const aPriority = a.landmark.is_priority ? 0 : 1;
-      const bPriority = b.landmark.is_priority ? 0 : 1;
-      if (aPriority !== bPriority) return aPriority - bPriority;
-      return a.d - b.d;
-    }).map(({ landmark }) => landmark);
-  };
-  const findNearestLandmark = (point2, levelId) => {
-    const nearbyLandmarks = findNearbyLandmarks(point2, levelId);
-    const nearestLandmark = nearbyLandmarks.length > 0 ? nearbyLandmarks[0] : null;
-    return nearestLandmark;
-  };
-  return { findNearbyLandmarks, findNearestLandmark };
-};
-
-// src/data/navigate/steps/utils/extractStartPoint.ts
-var import_center7 = require("@turf/center");
-
-// src/data/navigate/steps/utils/featureIdGuard.ts
-var isOccupant = (id) => !!id && id.startsWith("occupant-");
-var isUnit = (id) => !!id && id.startsWith("unit-");
-var isKiosk = (id) => !!id && id.startsWith("kiosk-");
-var isOpening = (id) => !!id && id.startsWith("opening-");
-
-// src/data/navigate/type-guard.ts
-function isCoordinateOrdinalString(id) {
-  return /^-?\d+(\.\d+)?,-?\d+(\.\d+)?,-?\d+(\.\d+)?o$/.test(id);
-}
-
-// src/data/navigate/steps/utils/extractStartPoint.ts
-var extractStartPoint = (path, options) => {
-  const { findByIdSync } = options;
-  const [a, b, c] = path;
-  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
-    const occ = findByIdSync(a);
-    const opening = findByIdSync(c);
-    const level = findByIdSync(opening.properties.level_id);
-    return [
-      {
-        id: occ.id,
-        type: "start",
-        name: occ.properties.name,
-        point: (0, import_center7.center)(opening).geometry.coordinates,
-        levelId: opening.properties.level_id,
-        ordinal: level.properties.ordinal,
-        source: { type: "opening", id: opening.id }
-      },
-      path.slice(3)
-    ];
-  }
-  if (isOccupant(a) && isKiosk(b)) {
-    const occ = findByIdSync(a);
-    const kiosk = findByIdSync(c);
-    const level = findByIdSync(kiosk.properties.level_id);
-    return [
-      {
-        id: occ.id,
-        type: "start",
-        name: occ.properties.name,
-        point: (0, import_center7.center)(kiosk).geometry.coordinates,
-        levelId: kiosk.properties.level_id,
-        ordinal: level.properties.ordinal,
-        source: { type: "kiosk", id: kiosk.id }
-      },
-      path.slice(2)
-    ];
-  }
-  if (isCoordinateOrdinalString(a) && isOpening(b)) {
-    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
-    const opening = findByIdSync(b);
-    return [
-      {
-        id: a,
-        type: "start",
-        name: { en: `Your location` },
-        point: [lng, lat],
-        levelId: opening.properties.level_id,
-        ordinal,
-        source: { type: "opening", id: opening.id }
-      },
-      path.slice(1)
-    ];
-  }
-  return [null, path];
-};
-
-// src/data/navigate/steps/utils/extractEndPint.ts
-var import_center8 = require("@turf/center");
-var extractEndPoint = (path, options) => {
-  const { findByIdSync } = options;
-  const [c, b, a] = path.slice(-3);
-  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
-    const occ = findByIdSync(a);
-    const opening = findByIdSync(c);
-    const level = findByIdSync(opening.properties.level_id);
-    return [
-      {
-        id: occ.id,
-        type: "end",
-        name: occ.properties.name,
-        point: (0, import_center8.center)(opening).geometry.coordinates,
-        levelId: opening.properties.level_id,
-        ordinal: level.properties.ordinal,
-        source: { type: "opening", id: opening.id }
-      },
-      path.slice(0, -3)
-    ];
-  }
-  if (isOccupant(a) && isKiosk(b)) {
-    const occ = findByIdSync(a);
-    const kiosk = findByIdSync(c);
-    const level = findByIdSync(kiosk.properties.level_id);
-    return [
-      {
-        id: occ.id,
-        type: "end",
-        name: occ.properties.name,
-        point: (0, import_center8.center)(kiosk).geometry.coordinates,
-        levelId: kiosk.properties.level_id,
-        ordinal: level.properties.ordinal,
-        source: { type: "kiosk", id: kiosk.id }
-      },
-      path.slice(0, -2)
-    ];
-  }
-  if (isCoordinateOrdinalString(a)) {
-    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
-    const opening = findByIdSync(b);
-    return [
-      {
-        id: a,
-        type: "end",
-        name: { en: `Your location` },
-        point: [lng, lat],
-        levelId: opening.properties.level_id,
-        ordinal,
-        source: { type: "opening", id: opening.id }
-      },
-      path.slice(0, -2)
-    ];
-  }
-  return [null, path];
-};
-
 // src/data/navigate/steps/utils/combineWalkwaySteps.ts
 var import_uniq = __toESM(require("lodash/uniq"));
 var combineWalkwaySteps = (steps) => {
@@ -2160,7 +1985,6 @@ var combineWalkwaySteps = (steps) => {
     }
     const nextStep = steps[i + 1];
     if (thisStep.intermediaryCategory === "walkway" && nextStep.intermediaryCategory === "walkway" && thisStep.from.source.type === "opening" && nextStep.from.source.type === "opening") {
-      console.log({ i, len: steps.length, thisStep, nextStep });
       result.push({
         from: thisStep.from,
         to: nextStep.to,
@@ -2184,15 +2008,14 @@ var combineWalkwaySteps = (steps) => {
 // src/data/navigate/steps/createStepUtils.ts
 var createStepUtils = (options) => {
   const { data: { units, relationships }, findByIdSync } = options;
-  const landmarkUtils = createLandmarkUtils(options);
   const stepPathUtils = createStepPathUtils({ ...options, resolution: 88e-5 });
   const findUnitBetweenOpenings = (originId, destinationId) => {
     const origin = findByIdSync(originId);
     const destination = findByIdSync(destinationId);
     const matchedOne = relationships.find((rel) => rel.properties.intermediary.map((int) => int.id).includes(origin.id));
-    const matchOneUnits = [matchedOne.properties.origin, matchedOne.properties.destination];
+    const matchOneUnits = matchedOne ? [matchedOne.properties.origin, matchedOne.properties.destination] : [];
     const matchedTwo = relationships.find((rel) => rel.properties.intermediary.map((int) => int.id).includes(destination.id));
-    const matchTwoUnits = [matchedTwo.properties.origin, matchedTwo.properties.destination];
+    const matchTwoUnits = matchedTwo ? [matchedTwo.properties.origin, matchedTwo.properties.destination] : [];
     const unitIds = (0, import_intersectionBy.default)(matchOneUnits, matchTwoUnits, "id");
     return unitIds.map(({ id }) => findByIdSync(id));
   };
@@ -2219,7 +2042,7 @@ var createStepUtils = (options) => {
   const formatCategoryLabel = (category) => {
     return (0, import_lodash12.capitalize)(category);
   };
-  const getToward = (from, to, intermediary) => {
+  const getNextStepIntermediary = (from, to, intermediary) => {
     if (to.type === "end") return to.name;
     const intermediaryIds = intermediary.map((int) => int.id);
     const relationship = relationships.find((rel) => rel.properties.intermediary.map((int) => int.id).includes(to.source.id));
@@ -2230,32 +2053,11 @@ var createStepUtils = (options) => {
     const nextUnit = findByIdSync(nextUnitId);
     return { en: formatCategoryLabel(`${nextUnit.properties.category}`) };
   };
-  const toWaypoints = (path) => {
-    const [startPoint, middleAndEndPoints] = extractStartPoint(path, options);
-    const [endPoint, middlePoints] = extractEndPoint(middleAndEndPoints, options);
-    const waypoints = middlePoints.map((openingId) => {
-      const opening = findByIdSync(openingId);
-      const level = findByIdSync(opening.properties.level_id);
-      const coordinates = (0, import_center9.center)(opening).geometry.coordinates;
-      const landmark = landmarkUtils.findNearestLandmark(coordinates, opening.properties.level_id);
-      return {
-        id: `${opening.properties.level_id}:${openingId}`,
-        type: "between",
-        point: coordinates,
-        name: null,
-        levelId: opening.properties.level_id,
-        ordinal: level.properties.ordinal,
-        hint: landmark ? { kind: "landmark", name: landmark.name } : void 0,
-        source: { type: "opening", id: opening.id }
-      };
-    });
-    return [startPoint, ...waypoints, endPoint];
-  };
   const createHorizontalStep = (from, to) => {
     const intermediary = findHorizontalIntermediary(from, to);
     const intermediaryCategories = intermediary.map((unit) => unit.properties.category);
     const intermediaryCategory = intermediaryCategories.length > 0 ? intermediaryCategories[0] : "unspecified";
-    const toward = getToward(from, to, intermediary);
+    const toward = getNextStepIntermediary(from, to, intermediary);
     const landmark = to.hint?.kind === "landmark" ? to.hint.name : null;
     const path = stepPathUtils.findStepPath(from.point, to.point, intermediary);
     const step = {
@@ -2312,8 +2114,6 @@ var createStepUtils = (options) => {
     return simplifySteps;
   };
   return {
-    // createSteps,
-    toWaypoints,
     toSteps
   };
 };
@@ -2334,6 +2134,11 @@ var calculateRoundedDistance = (distance5) => {
   return Math.round(distance5 - distance5 % 25);
 };
 
+// src/data/navigate/type-guard.ts
+function isCoordinateOrdinalString(id) {
+  return /^-?\d+(\.\d+)?,-?\d+(\.\d+)?,-?\d+(\.\d+)?o$/.test(id);
+}
+
 // src/data/navigate/utils/createFindByIdSync.ts
 var createFindByIdSync = (data) => {
   const { amenities = [], anchors = [], fixtures = [], levels = [], kiosks = [], relationships = [], occupants = [], openings = [], units } = data;
@@ -2356,6 +2161,207 @@ var createFindByIdSync = (data) => {
   return { findByIdSync };
 };
 
+// src/data/navigate/waypoint/createWaypointUtils.ts
+var import_center9 = require("@turf/center");
+
+// src/data/navigate/waypoint/extractEndWaypoint.ts
+var import_center6 = require("@turf/center");
+
+// src/data/navigate/waypoint/featureIdGuard.ts
+var isOccupant = (id) => !!id && id.startsWith("occupant-");
+var isUnit = (id) => !!id && id.startsWith("unit-");
+var isKiosk = (id) => !!id && id.startsWith("kiosk-");
+var isOpening = (id) => !!id && id.startsWith("opening-");
+
+// src/data/navigate/waypoint/extractEndWaypoint.ts
+var extractEndPoint = (path, options) => {
+  const { findByIdSync } = options;
+  const [c, b, a] = path.slice(-3);
+  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
+    const occ = findByIdSync(a);
+    const opening = findByIdSync(c);
+    const level = findByIdSync(opening.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "end",
+        name: occ.properties.name,
+        point: (0, import_center6.center)(opening).geometry.coordinates,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(0, -3)
+    ];
+  }
+  if (isOccupant(a) && isKiosk(b)) {
+    const occ = findByIdSync(a);
+    const kiosk = findByIdSync(b);
+    const level = findByIdSync(kiosk.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "end",
+        name: occ.properties.name,
+        point: (0, import_center6.center)(kiosk).geometry.coordinates,
+        levelId: kiosk.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "kiosk", id: kiosk.id }
+      },
+      path.slice(0, -2)
+    ];
+  }
+  if (isCoordinateOrdinalString(a) && isOpening(b)) {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
+    const opening = findByIdSync(b);
+    return [
+      {
+        id: a,
+        type: "end",
+        name: { en: a },
+        point: [lng, lat],
+        levelId: opening.properties.level_id,
+        ordinal,
+        source: { type: "coordinate", raw: a }
+      },
+      path.slice(0, -1)
+    ];
+  }
+  return [null, path];
+};
+
+// src/data/navigate/waypoint/extractStartWaypoint.ts
+var import_center7 = require("@turf/center");
+var extractStartPoint = (path, options) => {
+  const { findByIdSync } = options;
+  const [a, b, c] = path;
+  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
+    const occ = findByIdSync(a);
+    const opening = findByIdSync(c);
+    const level = findByIdSync(opening.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "start",
+        name: occ.properties.name,
+        point: (0, import_center7.center)(opening).geometry.coordinates,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(3)
+    ];
+  }
+  if (isOccupant(a) && isKiosk(b)) {
+    const occ = findByIdSync(a);
+    const kiosk = findByIdSync(b);
+    const level = findByIdSync(kiosk.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "start",
+        name: occ.properties.name,
+        point: (0, import_center7.center)(kiosk).geometry.coordinates,
+        levelId: kiosk.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "kiosk", id: kiosk.id }
+      },
+      path.slice(2)
+    ];
+  }
+  if (isCoordinateOrdinalString(a) && isOpening(b)) {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
+    const opening = findByIdSync(b);
+    return [
+      {
+        id: a,
+        type: "start",
+        name: { en: a },
+        point: [lng, lat],
+        levelId: opening.properties.level_id,
+        ordinal,
+        source: { type: "coordinate", raw: a }
+      },
+      path.slice(1)
+    ];
+  }
+  return [null, path];
+};
+
+// src/data/navigate/landmark/createLandmarkUtils.ts
+var import_center8 = require("@turf/center");
+var import_distance5 = __toESM(require("@turf/distance"));
+var NEARBY_DISTANCE = 30;
+var createLandmarkUtils = (options) => {
+  const { data, findByIdSync } = options;
+  const { occupants = [] } = data;
+  const occupantToLandmark = (occupant) => {
+    const locationType = occupant.properties.unit_id ? "unit" : "kiosk";
+    const locationId = locationType === "unit" ? occupant.properties.unit_id : occupant.properties.kiosk_id;
+    const location = locationType === "unit" ? findByIdSync(locationId) : findByIdSync(locationId);
+    const level = findByIdSync(location.properties.level_id);
+    return {
+      name: occupant.properties.name,
+      point: (0, import_center8.center)(location.geometry).geometry.coordinates,
+      level_id: location.properties.level_id,
+      is_priority: occupant.properties.is_landmark,
+      ordinal: level.properties.ordinal
+    };
+  };
+  const landmarks = [
+    ...occupants.map(occupantToLandmark)
+  ];
+  const findNearbyLandmarks = (point2, levelId) => {
+    if (point2 === null || levelId === null) return [];
+    return landmarks.map((landmark) => {
+      const landmarkAndDistance = {
+        landmark,
+        d: (0, import_distance5.default)(point2, landmark.point, { units: "meters" })
+      };
+      return landmarkAndDistance;
+    }).filter(({ landmark, d }) => d <= NEARBY_DISTANCE && landmark.level_id === levelId).sort((a, b) => {
+      const aPriority = a.landmark.is_priority ? 0 : 1;
+      const bPriority = b.landmark.is_priority ? 0 : 1;
+      if (aPriority !== bPriority) return aPriority - bPriority;
+      return a.d - b.d;
+    }).map(({ landmark }) => landmark);
+  };
+  const findNearestLandmark = (point2, levelId) => {
+    const nearbyLandmarks = findNearbyLandmarks(point2, levelId);
+    const nearestLandmark = nearbyLandmarks.length > 0 ? nearbyLandmarks[0] : null;
+    return nearestLandmark;
+  };
+  return { findNearbyLandmarks, findNearestLandmark };
+};
+
+// src/data/navigate/waypoint/createWaypointUtils.ts
+var createWaypointUtils = (options) => {
+  const { findByIdSync } = options;
+  const landmarkUtils = createLandmarkUtils(options);
+  const toWaypoints = (path) => {
+    const [startPoint, middleAndEndPoints] = extractStartPoint(path, options);
+    const [endPoint, middlePoints] = extractEndPoint(middleAndEndPoints, options);
+    const waypoints = middlePoints.map((openingId) => {
+      const opening = findByIdSync(openingId);
+      const level = findByIdSync(opening.properties.level_id);
+      const coordinates = (0, import_center9.center)(opening).geometry.coordinates;
+      const landmark = landmarkUtils.findNearestLandmark(coordinates, opening.properties.level_id);
+      return {
+        id: `${opening.properties.level_id}:${openingId}`,
+        type: "between",
+        point: coordinates,
+        name: null,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        hint: landmark ? { kind: "landmark", name: landmark.name } : void 0,
+        source: { type: "opening", id: opening.id }
+      };
+    });
+    return [startPoint, ...waypoints, endPoint];
+  };
+  return { toWaypoints };
+};
+
 // src/data/navigate/getNavigateClient.ts
 var getNavigateClient = (options) => {
   const { data } = options;
@@ -2377,6 +2383,7 @@ var getNavigateClient = (options) => {
     return unit;
   };
   const stepUtils = createStepUtils({ ...options, findByIdSync });
+  const waypointUtils = createWaypointUtils({ ...options, findByIdSync });
   const findRoute = async (routeOriginParam, routeDestinationParam, options2) => {
     if (!routeOriginParam || !routeDestinationParam) return null;
     const graph = options2?.mode === "accessible" ? accessibleGraph : defaultGraph;
@@ -2394,8 +2401,7 @@ var getNavigateClient = (options) => {
       const path = graph.path(routeOriginParam, routeDestinationParam);
       const t12 = performance.now();
       trace("nav", "  \u251C\u2500 path (dijkstra)", t12 - t02);
-      const waypoints = stepUtils.toWaypoints(path);
-      console.log({ waypoints });
+      const waypoints = waypointUtils.toWaypoints(path);
       const t22 = performance.now();
       trace("nav", "  \u251C\u2500 toWaypoints", t22 - t12);
       trace("nav", "  \u251C\u2500 toSteps", 0);
@@ -2407,9 +2413,6 @@ var getNavigateClient = (options) => {
       const t4 = performance.now();
       trace("nav", "  \u2514\u2500 postProcess", t4 - t32);
       return {
-        // origin: routeOrigin,
-        // destination: routeDestination,
-        description: null,
         distance: roundedDistance,
         duration,
         steps
@@ -6616,6 +6619,7 @@ var IndoorMap = class extends EventTarget {
   getLocationByFeature,
   getLocationByOccupant,
   getLocationIdByFeature,
+  getNavigateClient,
   getOrdinalByLocationId,
   getRelatedLocationIdsByFeature,
   getRelatedLocationsByAmenity,