venue-js 1.2.0-next.1 → 1.2.0-next.10

package/dist/index.mjs

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/data/index.ts
 import { QueryObserver as QueryObserver2 } from "@tanstack/query-core";
 
@@ -191,6 +197,115 @@ 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 = (polygon) => {
+  if (Array.isArray(polygon[0]) && (polygon[0].length === 0 || typeof polygon[0][0] === "number")) {
+    return isValidLinearRingCoordinates(polygon);
+  }
+  if (Array.isArray(polygon) && polygon.length > 0 && Array.isArray(polygon[0])) {
+    if (!isValidLinearRingCoordinates(polygon[0])) {
+      return false;
+    }
+    for (let i = 1; i < polygon.length; i++) {
+      if (!isValidLinearRingCoordinates(polygon[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
+});
+import _compact from "lodash/compact";
+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
 import {
   QueryClient,
@@ -349,8 +464,8 @@ var createPopulator = ({
         venue,
         promotions,
         privileges,
-        kiosk,
-        unit,
+        kiosk: kiosk ? await populateKiosk(kiosk) : null,
+        unit: unit ? await populateUnit(unit) : null,
         kiosks: await Promise.all(kiosks.map(populateKiosk)),
         units: await Promise.all(units.map(populateUnit))
       }
@@ -442,26 +557,6 @@ var createPopulator = ({
   };
 };
 
-// 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/getDataClient.ts
 var getDataClient = (options) => {
   const observers = /* @__PURE__ */ new Map();
@@ -593,11 +688,13 @@ import {
   ui as ui3,
   Map as Map2,
   TileLayer,
-  Extent,
   LineString as LineString3,
   Marker as Marker2,
-  Coordinate as Coordinate4
+  Coordinate as Coordinate4,
+  GroupGLLayer,
+  GLTFLayer
 } from "maptalks-gl";
+import "@maptalks/transcoders.draco";
 import TWEEN2 from "@tweenjs/tween.js";
 import _6 from "lodash";
 
@@ -679,133 +776,8 @@ function isNumber(num) {
 // src/IndoorMap/IndoorMap.ts
 import turfDistance from "@turf/distance";
 import turfCenter3 from "@turf/center";
-
-// ../../node_modules/@turf/meta/dist/esm/index.js
-function coordEach(geojson, callback, excludeWrapCoord) {
-  if (geojson === null) return;
-  var j, k, l, geometry, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
-  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
-    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
-    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
-    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
-    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
-      var multiFeatureIndex = 0;
-      var geometryIndex = 0;
-      geometry = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
-      if (geometry === null) continue;
-      coords = geometry.coordinates;
-      var geomType = geometry.type;
-      wrapShrink = excludeWrapCoord && (geomType === "Polygon" || geomType === "MultiPolygon") ? 1 : 0;
-      switch (geomType) {
-        case null:
-          break;
-        case "Point":
-          if (callback(
-            coords,
-            coordIndex,
-            featureIndex,
-            multiFeatureIndex,
-            geometryIndex
-          ) === false)
-            return false;
-          coordIndex++;
-          multiFeatureIndex++;
-          break;
-        case "LineString":
-        case "MultiPoint":
-          for (j = 0; j < coords.length; j++) {
-            if (callback(
-              coords[j],
-              coordIndex,
-              featureIndex,
-              multiFeatureIndex,
-              geometryIndex
-            ) === false)
-              return false;
-            coordIndex++;
-            if (geomType === "MultiPoint") multiFeatureIndex++;
-          }
-          if (geomType === "LineString") multiFeatureIndex++;
-          break;
-        case "Polygon":
-        case "MultiLineString":
-          for (j = 0; j < coords.length; j++) {
-            for (k = 0; k < coords[j].length - wrapShrink; k++) {
-              if (callback(
-                coords[j][k],
-                coordIndex,
-                featureIndex,
-                multiFeatureIndex,
-                geometryIndex
-              ) === false)
-                return false;
-              coordIndex++;
-            }
-            if (geomType === "MultiLineString") multiFeatureIndex++;
-            if (geomType === "Polygon") geometryIndex++;
-          }
-          if (geomType === "Polygon") multiFeatureIndex++;
-          break;
-        case "MultiPolygon":
-          for (j = 0; j < coords.length; j++) {
-            geometryIndex = 0;
-            for (k = 0; k < coords[j].length; k++) {
-              for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
-                if (callback(
-                  coords[j][k][l],
-                  coordIndex,
-                  featureIndex,
-                  multiFeatureIndex,
-                  geometryIndex
-                ) === false)
-                  return false;
-                coordIndex++;
-              }
-              geometryIndex++;
-            }
-            multiFeatureIndex++;
-          }
-          break;
-        case "GeometryCollection":
-          for (j = 0; j < geometry.geometries.length; j++)
-            if (coordEach(geometry.geometries[j], callback, excludeWrapCoord) === false)
-              return false;
-          break;
-        default:
-          throw new Error("Unknown Geometry Type");
-      }
-    }
-  }
-}
-
-// ../../node_modules/@turf/bbox/dist/esm/index.js
-function bbox(geojson, options = {}) {
-  if (geojson.bbox != null && true !== options.recompute) {
-    return geojson.bbox;
-  }
-  const result = [Infinity, Infinity, -Infinity, -Infinity];
-  coordEach(geojson, (coord) => {
-    if (result[0] > coord[0]) {
-      result[0] = coord[0];
-    }
-    if (result[1] > coord[1]) {
-      result[1] = coord[1];
-    }
-    if (result[2] < coord[0]) {
-      result[2] = coord[0];
-    }
-    if (result[3] < coord[1]) {
-      result[3] = coord[1];
-    }
-  });
-  return result;
-}
-var index_default = bbox;
-
-// src/IndoorMap/IndoorMap.ts
-import scale from "@turf/transform-scale";
-import bboxPolygon from "@turf/bbox-polygon";
 import { PerspectiveCamera } from "three";
+import { ThreeLayer as ThreeLayer4 } from "maptalks.three";
 
 // src/IndoorMap/constants.ts
 var defaultLayerOption = { enableAltitude: true };
@@ -1827,18 +1799,6 @@ var loadModel3d = (model3d, coordinate, threeLayer) => {
     );
   });
 };
-var create3DModels = async (models, defaultCoordinate, properties, threeLayer) => {
-  let modelObjs = [];
-  for (let j = 0; j < models.length; j++) {
-    const model = models[j];
-    const positionCoord = _4.get(model, "properties.position");
-    const coord = positionCoord || defaultCoordinate;
-    const object = await loadModel3d(model, coord, threeLayer);
-    object.properties = properties;
-    modelObjs.push(object);
-  }
-  return modelObjs;
-};
 var createExtrudePolygon = (geometry, threeLayer, material, height, properties = {}, options) => {
   const { offset = 0, altitude = 0 } = options;
   const offsetGeometry = turfBuffer(geometry, offset, { units: "meters" });
@@ -2746,44 +2706,6 @@ var styledFeatureGenerator = (mapTheme) => {
         markerProperties
       );
     },
-    createVenue3DModel: async (venue, threeLayer) => {
-      const { id, feature_type, properties } = venue;
-      const { category, model3d } = properties;
-      const modelProperty = {
-        id,
-        feature_type,
-        category
-      };
-      const center2 = turfCenter(venue);
-      const centerCoord = _4.get(center2, "geometry.coordinates");
-      const modelPosition = _4.get(model3d, "properties.position", centerCoord);
-      const models = await create3DModels(
-        model3d,
-        modelPosition,
-        modelProperty,
-        threeLayer
-      );
-      return models;
-    },
-    create3DFixture: async (fixture, threeLayer) => {
-      const { id, feature_type, properties } = fixture;
-      const { category, ordinal, model3d } = properties;
-      const modelProperty = {
-        id,
-        feature_type,
-        category,
-        ordinal
-      };
-      const center2 = turfCenter(fixture);
-      const coordinate = _4.get(center2, "geometry.coordinates");
-      const models = await create3DModels(
-        model3d,
-        coordinate,
-        modelProperty,
-        threeLayer
-      );
-      return models;
-    },
     createExtrudedUnit: (unit, threeLayer, options) => {
       const extrudeHeight = _4.get(options, "height");
       if (!extrudeHeight) return;
@@ -2823,24 +2745,6 @@ var styledFeatureGenerator = (mapTheme) => {
         options3d
       );
       return object;
-    },
-    createAmbientLight: (config) => {
-      const { color: colorString = "0xffffff", intensity = 1 } = config;
-      const color = parseInt(colorString, 16);
-      const ambientLight = new AmbientLight(color, intensity);
-      return ambientLight;
-    },
-    createDirectionalLight: (config) => {
-      const {
-        color: colorString = "0xffffff",
-        intensity = 1,
-        position: positionString = [0, 0, 0]
-      } = config;
-      const color = parseInt(colorString, 16);
-      const [x, y, z] = positionString;
-      const light = new DirectionalLight(color, intensity);
-      light.position.set(x, y, z).normalize();
-      return light;
     }
   };
 };
@@ -3010,311 +2914,229 @@ var createHighlighExtrudeObjectController = (obj, { color }) => {
 };
 
 // src/IndoorMap/camera/CameraManager.ts
-var ZOOM_OUT_LEVEL = 21;
-var ZOOM_IN_LEVEL = 24;
-var CameraManager = class {
-  map;
-  constructor(map, options) {
-    this.map = map;
-    if (options?.defaultView) {
-      this.setView(options?.defaultView);
-    }
-  }
-  /** Private method */
-  #animateflyTo(viewOptions = {}, options = {}, callbackOption = () => {
-  }) {
-    const { start, end } = {
-      start: (frame) => {
-      },
-      end: (frame) => {
-      },
-      ...callbackOption
-    };
-    this.map.flyTo(viewOptions, options, (frame) => {
-      if (frame.state.playState === "running" && frame.state.progress === 0)
-        start(frame);
-      if (frame.state.playState === "finished") end(frame);
-    });
-  }
-  /** Public methods */
-  getView = () => {
-    return this.map.getView();
-  };
-  getZoom = () => {
-    return this.map.getView().zoom;
-  };
-  setView = (value) => {
-    this.map.setView(value);
-  };
-  flyTo = (center2, options = {}) => {
-    const currentView = this.getView();
-    const {
-      zoom = ZOOM_OUT_LEVEL,
-      pitch = 60,
-      duration = 600,
-      easing = "out",
-      bearing = currentView.bearing
-    } = options;
-    this.#animateflyTo(
-      {
-        center: center2,
-        zoom,
-        pitch,
-        bearing
-      },
-      { duration, easing }
-    );
-  };
-  flyToAndZoomIn = (centerPoint, options = {}) => {
-    const {
-      zoom = ZOOM_IN_LEVEL,
-      pitch = 60,
-      duration = 600,
-      easing = "out"
-    } = options;
-    this.#animateflyTo(
-      {
-        center: centerPoint,
-        zoom,
-        pitch
-      },
-      { duration, easing }
-    );
-  };
-};
-
-// src/IndoorMap/renderer/RendererManager.ts
-import _min from "lodash/min";
-import { center as turfCenter2 } from "@turf/center";
-import { ThreeLayer as ThreeLayer3 } from "maptalks.three";
-import * as THREE3 from "three";
-
-// src/IndoorMap/renderer/3d/Element3DRenderer.ts
-import * as maptalks4 from "maptalks";
-import * as THREE2 from "three";
-import { GLTFLoader as GLTFLoader2 } from "three/examples/jsm/loaders/GLTFLoader";
-import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader";
-import turfBuffer2 from "@turf/buffer";
+import { Extent } from "maptalks";
 
-// src/IndoorMap/renderer/3d/element3DRendererOptions.ts
-var element3DRendererOptions = {
-  unit: {
-    default: { color: "#ffffff", height: 4 },
-    byCategory: {
-      walkway: { color: "#cccccc", height: 0.1 },
-      terrace: { color: "#cccccc", height: 0.1 },
-      unenclosedarea: { color: "#cccccc", height: 0.2 },
-      nonpublic: { color: "#999999", height: 0.3 },
-      escalator: { height: 0.2 },
-      room: { color: "#ffffff", height: 2, bottomHeight: 0.12 }
-    }
-  },
-  kiosk: {
-    default: { color: "#666666", height: 0.6, bottomHeight: 0.12 }
-  },
-  fixture: {
-    default: { color: "#ffffff", height: 0.5 },
-    byCategory: {
-      water: { color: "#ACD7EC", height: 0.1 },
-      vegetation: { color: "#91C499", height: 0.5 }
+// ../../node_modules/@turf/meta/dist/esm/index.js
+function coordEach(geojson, callback, excludeWrapCoord) {
+  if (geojson === null) return;
+  var j, k, l, geometry, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
+      var multiFeatureIndex = 0;
+      var geometryIndex = 0;
+      geometry = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+      if (geometry === null) continue;
+      coords = geometry.coordinates;
+      var geomType = geometry.type;
+      wrapShrink = excludeWrapCoord && (geomType === "Polygon" || geomType === "MultiPolygon") ? 1 : 0;
+      switch (geomType) {
+        case null:
+          break;
+        case "Point":
+          if (callback(
+            coords,
+            coordIndex,
+            featureIndex,
+            multiFeatureIndex,
+            geometryIndex
+          ) === false)
+            return false;
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        case "LineString":
+        case "MultiPoint":
+          for (j = 0; j < coords.length; j++) {
+            if (callback(
+              coords[j],
+              coordIndex,
+              featureIndex,
+              multiFeatureIndex,
+              geometryIndex
+            ) === false)
+              return false;
+            coordIndex++;
+            if (geomType === "MultiPoint") multiFeatureIndex++;
+          }
+          if (geomType === "LineString") multiFeatureIndex++;
+          break;
+        case "Polygon":
+        case "MultiLineString":
+          for (j = 0; j < coords.length; j++) {
+            for (k = 0; k < coords[j].length - wrapShrink; k++) {
+              if (callback(
+                coords[j][k],
+                coordIndex,
+                featureIndex,
+                multiFeatureIndex,
+                geometryIndex
+              ) === false)
+                return false;
+              coordIndex++;
+            }
+            if (geomType === "MultiLineString") multiFeatureIndex++;
+            if (geomType === "Polygon") geometryIndex++;
+          }
+          if (geomType === "Polygon") multiFeatureIndex++;
+          break;
+        case "MultiPolygon":
+          for (j = 0; j < coords.length; j++) {
+            geometryIndex = 0;
+            for (k = 0; k < coords[j].length; k++) {
+              for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
+                if (callback(
+                  coords[j][k][l],
+                  coordIndex,
+                  featureIndex,
+                  multiFeatureIndex,
+                  geometryIndex
+                ) === false)
+                  return false;
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+          break;
+        case "GeometryCollection":
+          for (j = 0; j < geometry.geometries.length; j++)
+            if (coordEach(geometry.geometries[j], callback, excludeWrapCoord) === false)
+              return false;
+          break;
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
     }
   }
-};
-
-// src/IndoorMap/renderer/3d/objects/TextSpriteMarker.ts
-import { Coordinate as Coordinate2, Util as Util4 } from "maptalks";
-import * as THREE from "three";
-import { BaseObject as BaseObject5 } from "maptalks.three";
-import { isNil, set } from "lodash";
+}
 
-// src/IndoorMap/renderer/utils/interpolateStops.ts
-var interpolateStops = ({ stops }, zoom) => {
-  if (zoom <= stops[0][0]) return stops[0][1];
-  if (zoom >= stops[stops.length - 1][0]) return stops[stops.length - 1][1];
-  for (let i = 0; i < stops.length - 1; i++) {
-    const [z1, v1] = stops[i];
-    const [z2, v2] = stops[i + 1];
-    if (zoom >= z1 && zoom <= z2) {
-      const t = (zoom - z1) / (z2 - z1);
-      return v1 + t * (v2 - v1);
-    }
+// ../../node_modules/@turf/bbox/dist/esm/index.js
+function bbox(geojson, options = {}) {
+  if (geojson.bbox != null && true !== options.recompute) {
+    return geojson.bbox;
   }
-};
+  const result = [Infinity, Infinity, -Infinity, -Infinity];
+  coordEach(geojson, (coord) => {
+    if (result[0] > coord[0]) {
+      result[0] = coord[0];
+    }
+    if (result[1] > coord[1]) {
+      result[1] = coord[1];
+    }
+    if (result[2] < coord[0]) {
+      result[2] = coord[0];
+    }
+    if (result[3] < coord[1]) {
+      result[3] = coord[1];
+    }
+  });
+  return result;
+}
+var index_default = bbox;
 
-// src/IndoorMap/renderer/3d/objects/TextSpriteMarker.ts
-var OPTIONS4 = {
-  // Texture options
-  text: "",
-  textAlign: "center",
-  color: "#ffffff",
-  fontFamily: "sans-serif",
-  fontSize: 28,
-  fontWeight: 400,
-  background: "rgba(0, 0, 0, 0.2)",
-  lineHeight: 32,
-  padding: 8,
-  strokeColor: "#000000",
-  strokeWidth: 6,
-  strokeStyle: "round",
-  // Sprite options
-  /* Overall scale multiplier  */
-  scale: 1,
-  altitude: 0,
-  opacity: 1
-};
-var TextSpriteMarker = class extends BaseObject5 {
-  #altitudeOffset = 0;
-  constructor(coordinate, options, layer, properties = {}) {
-    options = Util4.extend({}, OPTIONS4, options, { layer });
-    super();
-    this._coordinate = new Coordinate2(coordinate);
-    this._initOptions(options);
-    this._createGroup();
-    this.properties = { ...properties };
-    const sprite = this._createSprite();
-    this.getObject3d().add(sprite);
-    this._updatePosition();
-    this.type = "TextSpriteMarker";
-  }
-  getOptions() {
-    return super.getOptions();
-  }
-  _createSprite() {
-    const options = this.getOptions();
-    const texture = this._createTextTexture(options.text, options);
-    const material = new THREE.SpriteMaterial({
-      map: texture,
-      transparent: true,
-      alphaTest: 0.1
-    });
-    const sprite = new THREE.Sprite(material);
-    const w = texture.image.width;
-    const h = texture.image.height;
-    const base = 1 / 16;
-    const normalizedScale = options.scale / this.getMap().getGLRes();
-    sprite.scale.set(w * base * normalizedScale, h * base * normalizedScale, 1);
-    this.#altitudeOffset = Math.max(
-      h * base * options.scale * 0.5,
-      0.05
-      // minimum lift in world units
-    );
-    return sprite;
-  }
-  _createTextTexture(text, options = {}) {
-    const {
-      padding,
-      fontSize,
-      fontFamily,
-      fontWeight,
-      lineHeight,
-      background,
-      color,
-      textAlign,
-      strokeColor,
-      strokeWidth,
-      maxWidth
-    } = options || {};
-    const canvas = document.createElement("canvas");
-    const ctx = canvas.getContext("2d");
-    ctx.font = `${fontWeight} ${fontSize}px ${fontFamily}`;
-    const paragraphs = String(text).split("\n");
-    const wrappedLines = [];
-    paragraphs.forEach((paragraph) => {
-      if (isNil(maxWidth) || isNaN(maxWidth)) {
-        wrappedLines.push(paragraph);
-        return;
-      }
-      const words = paragraph.split(/\s+/);
-      let currentLine = "";
-      words.forEach((word) => {
-        const testLine = currentLine ? currentLine + " " + word : word;
-        const testWidth = ctx.measureText(testLine).width;
-        if (testWidth > maxWidth && currentLine) {
-          wrappedLines.push(currentLine);
-          currentLine = word;
-        } else {
-          currentLine = testLine;
-        }
-      });
-      if (currentLine) {
-        wrappedLines.push(currentLine);
-      }
-    });
-    const lines = wrappedLines.length ? wrappedLines : [""];
-    const widest = Math.max(...lines.map((l) => ctx.measureText(l).width), 0);
-    const finalWidth = (maxWidth ? Math.min(widest, maxWidth) : widest) + padding * 2;
-    const finalHeight = lineHeight * lines.length + padding * 2;
-    canvas.width = finalWidth;
-    canvas.height = finalHeight;
-    const ctx2 = canvas.getContext("2d");
-    ctx2.font = `${fontWeight} ${fontSize}px ${fontFamily}`;
-    ctx2.textAlign = textAlign;
-    if (background && background !== "transparent") {
-      ctx2.fillStyle = background;
-      ctx2.fillRect(0, 0, canvas.width, canvas.height);
+// src/IndoorMap/camera/CameraManager.ts
+import scale from "@turf/transform-scale";
+import bboxPolygon from "@turf/bbox-polygon";
+var CameraManager = class {
+  map;
+  constructor(map, options) {
+    this.map = map;
+    if (options?.defaultView) {
+      this.setView(options?.defaultView);
     }
-    lines.forEach((line, i) => {
-      const y = padding + lineHeight * (i + 0.8);
-      let x = padding;
-      if (textAlign === "center") x = canvas.width / 2;
-      if (textAlign === "right" || textAlign === "end")
-        x = canvas.width - padding;
-      if (strokeWidth > 0) {
-        ctx2.lineWidth = strokeWidth;
-        ctx2.lineJoin = "round";
-        ctx2.miterLimit = 2;
-        ctx2.strokeStyle = strokeColor;
-        ctx2.strokeText(line, x, y);
-      }
-      ctx2.fillStyle = color;
-      ctx2.fillText(line, x, y);
-    });
-    const texture = new THREE.CanvasTexture(canvas);
-    texture.needsUpdate = true;
-    texture.minFilter = THREE.LinearFilter;
-    return texture;
   }
-  _updatePosition() {
-    const options = this.getOptions();
-    const layer = options.layer;
-    if (!layer) return;
-    const altitude = (options.altitude || 0) + this.#altitudeOffset;
-    const z = layer.altitudeToVector3(altitude, altitude).x;
-    const position = layer.coordinateToVector3(this._coordinate, z);
-    set(this.properties, "default.position", position);
-    this.getObject3d().position.copy(position);
+  /** Public methods */
+  getView = () => {
+    return this.map.getView();
+  };
+  setView = (value) => {
+    if (this.map && Object.keys(value).length !== 0) {
+      this.map.setView(value);
+    }
+  };
+  animateTo = (view, options = {}, step) => {
+    this.map.animateTo(view, options, step);
+  };
+  setMaxExtent(extent) {
+    return this.map.setMaxExtent(extent);
   }
-  _animation() {
-    const layer = this.getLayer();
-    if (!this.isAdd || !layer) return;
-    if (this._visible === true) {
-      const zoom = layer.map.getZoom();
-      const object3d = this.getObject3d();
-      const { opacity } = this.getOptions();
-      let opacityValue;
-      if (typeof opacity === "number") {
-        opacityValue = opacity ?? 1;
-      } else if (Array.isArray(opacity.stops)) {
-        opacityValue = interpolateStops(opacity, zoom);
-      } else {
-        throw new Error(`Unknown opacity value ${opacity}`);
-      }
-      const visible = opacityValue > 0.5;
-      object3d.visible = visible;
+  getFeatureExtent = (feature2, scaleFactor = 1) => {
+    const [minX, minY, maxX, maxY] = index_default(
+      scale(bboxPolygon(index_default(feature2)), scaleFactor)
+    );
+    return new Extent(minX, minY, maxX, maxY);
+  };
+  getExtentZoom = (extent, options = {
+    isFraction: false,
+    padding: {
+      paddingLeft: 0,
+      paddingRight: 0,
+      paddingTop: 0,
+      paddingBottom: 0
     }
+  }) => {
+    const { isFraction = false, padding } = options;
+    return this.map.getFitZoom(extent, isFraction, padding);
+  };
+  set maxZoom(value) {
+    this.map.setMaxZoom(value);
+    const spatialReference = {
+      projection: "EPSG:3857",
+      resolutions: (function() {
+        const resolutions = [];
+        const d = 2 * 6378137 * Math.PI;
+        for (let i = 0; i < value; i++) {
+          resolutions[i] = d / (256 * Math.pow(2, i));
+        }
+        return resolutions;
+      })()
+    };
+    this.map.setSpatialReference(spatialReference);
   }
-  setText(text) {
-    const options = this.getOptions();
-    options.text = text;
-    const newSprite = this._createSprite();
-    const group = this.getObject3d();
-    group.children.forEach((child) => group.remove(child));
-    group.add(newSprite);
-    this._updatePosition();
+  set minZoom(value) {
+    this.map.setMinZoom(value);
   }
-  setAltitude(altitude) {
-    const bottomHeight = this.options.bottomHeight ?? 0;
-    return super.setAltitude(altitude + bottomHeight + this.#altitudeOffset);
+};
+
+// src/IndoorMap/renderer/RendererManager.ts
+import _isFunction from "lodash/isFunction";
+import _min from "lodash/min";
+import { center as turfCenter2 } from "@turf/center";
+import * as THREE3 from "three";
+
+// src/IndoorMap/renderer/3d/Element3DRenderer.ts
+import * as maptalks4 from "maptalks-gl";
+import * as THREE from "three";
+import { BaseObject as BaseObject5 } from "maptalks.three";
+import turfBuffer2 from "@turf/buffer";
+
+// src/IndoorMap/renderer/3d/element3DRendererOptions.ts
+var element3DRendererOptions = {
+  unit: {
+    default: { color: "#ffffff", height: 4 },
+    byCategory: {
+      walkway: { color: "#cccccc", height: 0.1 },
+      terrace: { color: "#cccccc", height: 0.1 },
+      unenclosedarea: { color: "#cccccc", height: 0.2 },
+      nonpublic: { color: "#999999", height: 0.3 },
+      escalator: { height: 0.2 },
+      parking: { height: 0.1 },
+      room: { color: "#ffffff", height: 2, bottomHeight: 0.12 }
+    }
+  },
+  kiosk: {
+    default: { color: "#666666", height: 0.6, bottomHeight: 0.12 }
+  },
+  fixture: {
+    default: { color: "#ffffff", height: 0.5 },
+    byCategory: {
+      water: { color: "#ACD7EC", height: 0.1 },
+      vegetation: { color: "#91C499", height: 0.5 }
+    }
   }
 };
 
@@ -3338,21 +3160,22 @@ var getGeometryOption = (feature2, options) => {
 var Element3DRenderer = class extends EventTarget {
   options;
   map;
+  gltfLayer;
   threeLayer;
-  dracoLoader;
+  scene;
+  // private dracoLoader: DRACOLoader
   lineMaterial;
   materialByColorMap;
-  markerRenderer;
   // Renderer is Ready
   isReady = false;
-  constructor(map, options, layer) {
+  constructor(map, options) {
     super();
     this.options = options;
     this.map = map;
-    this.dracoLoader = new DRACOLoader();
-    this.dracoLoader.setDecoderPath("https://www.gstatic.com/draco/versioned/decoders/1.5.7/");
-    this.lineMaterial = new THREE2.LineBasicMaterial({ color: "#000" });
-    this.threeLayer = layer;
+    const groupLayer = this.map.getLayer("group");
+    this.threeLayer = groupLayer.getLayer("three");
+    this.gltfLayer = groupLayer.getLayer("gltf");
+    this.lineMaterial = new THREE.LineBasicMaterial({ color: "#000" });
     this.render();
   }
   animation() {
@@ -3367,7 +3190,7 @@ var Element3DRenderer = class extends EventTarget {
     if (!this.materialByColorMap) this.materialByColorMap = /* @__PURE__ */ new Map();
     const existingMaterial = this.materialByColorMap.get(color);
     if (existingMaterial) return existingMaterial;
-    const created = new THREE2.MeshLambertMaterial({ color, transparent: true });
+    const created = new THREE.MeshLambertMaterial({ color, transparent: true });
     created.toneMapped = false;
     this.materialByColorMap.set(color, created);
     return created;
@@ -3382,46 +3205,48 @@ var Element3DRenderer = class extends EventTarget {
     } = getGeometryOption(feature2, this.options);
     const _this = this;
     const createPolygon = (geometry, feature3) => {
-      const [outerRing, ...innerRings] = geometry.coordinates;
-      const offsetFeature = offset !== 0 ? turfBuffer2(geometry, offset, { units: "meters" }) : feature3;
-      const color = feature3.properties.style.polygonFill ?? colorOptions ?? "#ffffff";
-      if (color === "transparent") return;
-      const material = this.getOrCreateMaterialByColor(color);
-      const altitude = feature3.properties.ordinal * HEIGHT_METER;
-      const height = feature3.properties.height ?? heightOptions ?? HEIGHT_METER;
-      const bottomHeight = feature3.properties.bottomHeight ?? bottomHeightOptions ?? 0;
-      const extrudedPolygon = this.threeLayer.toExtrudePolygon(
-        offsetFeature,
-        { asynchronous: true, ...options, height, bottomHeight, altitude },
-        material
-      );
-      extrudedPolygon.on("click", (e) => {
-        console.log(e.target.options.polygon.id);
-      });
-      const topLineStrings = [
-        new maptalks4.LineString(outerRing),
-        ...innerRings.map((innerRing) => new maptalks4.LineString(innerRing))
-      ];
-      const topLines = this.threeLayer.toLines(
-        topLineStrings,
-        { altitude, bottomHeight: bottomHeight + height + 1e-3, interactive: false },
-        this.lineMaterial
-      );
-      const bottomLineStrings = [
-        new maptalks4.LineString(outerRing),
-        ...innerRings.map((innerRing) => new maptalks4.LineString(innerRing))
-      ];
-      const bottomLines = this.threeLayer.toLines(
-        bottomLineStrings,
-        { altitude, bottomHeight, interactive: false },
-        this.lineMaterial
-      );
-      return [extrudedPolygon, topLines, bottomLines];
+      try {
+        const [outerRing, ...innerRings] = geometry.coordinates;
+        const offsetFeature = offset !== 0 ? turfBuffer2(geometry, offset, { units: "meters" }) : feature3;
+        const color = feature3.properties.style.polygonFill ?? colorOptions ?? "#ffffff";
+        if (color === "transparent") return;
+        const material = this.getOrCreateMaterialByColor(color);
+        const altitude = 0;
+        const height = feature3.properties.height ?? heightOptions ?? HEIGHT_METER;
+        const bottomHeight = feature3.properties.bottomHeight ?? bottomHeightOptions ?? 0;
+        const extrudedPolygon = this.threeLayer.toExtrudePolygon(
+          offsetFeature,
+          { asynchronous: true, ...options, height, bottomHeight, altitude },
+          material
+        );
+        const topLineStrings = [
+          new maptalks4.LineString(outerRing),
+          ...innerRings.map((innerRing) => new maptalks4.LineString(innerRing))
+        ];
+        const topLines = this.threeLayer.toLines(
+          topLineStrings,
+          { altitude, bottomHeight: bottomHeight + height + 1e-3, interactive: false },
+          this.lineMaterial
+        );
+        const bottomLineStrings = [
+          new maptalks4.LineString(outerRing),
+          ...innerRings.map((innerRing) => new maptalks4.LineString(innerRing))
+        ];
+        const bottomLines = this.threeLayer.toLines(
+          bottomLineStrings,
+          { altitude, bottomHeight, interactive: false },
+          this.lineMaterial
+        );
+        return [extrudedPolygon, topLines, bottomLines];
+      } catch (err) {
+        return [];
+      }
     };
     try {
       switch (feature2.geometry.type) {
         case "MultiPolygon": {
           const { coordinates } = feature2.geometry;
+          if (!coordinates) return [];
           const multiMeshes = coordinates.flatMap((polygonCoordinates) => {
             const meshes = createPolygon({ type: "Polygon", coordinates: polygonCoordinates }, feature2);
             this.threeLayer.addMesh(meshes);
@@ -3430,70 +3255,47 @@ var Element3DRenderer = class extends EventTarget {
           return multiMeshes;
         }
         case "Polygon": {
+          const { coordinates } = feature2.geometry;
+          if (!coordinates) return [];
           const meshes = createPolygon(feature2.geometry, feature2);
           this.threeLayer.addMesh(meshes);
           return meshes;
         }
       }
     } catch (err) {
-      console.log(`error createGeometry`, { feature: feature2, options });
+      console.log(`error createGeometry`, err, { feature: feature2, options });
     }
   };
   async createEscalator(f, coordinate, options) {
+    const model = {
+      url: "https://cdn.venue.in.th/static/glb/escalator.glb",
+      size: 4.4
+    };
     const { direction: dir, angle } = options;
-    const model = await this.loadModel3d({
-      url: "https://dashboard.situm.com/uploads/3dmodels/demoaccount/new_escalator.glb",
-      properties: {
-        rotation: {
-          x: 0.5 * Math.PI,
-          // Rotate the model up (new_escalator.glb)
-          y: 0,
-          z: 0
-        },
-        position: { x: 0, y: 0, z: 0 },
-        scale: 0.01
+    const rotationZ = dir === "up" ? 180 + angle : angle;
+    var escalatorMarker = new maptalks4.GLTFMarker(coordinate, {
+      symbol: {
+        url: model.url,
+        rotationZ,
+        translationX: dir === "up" ? 0 : model.size * Math.cos(Math.PI * rotationZ / 180),
+        translationY: dir === "up" ? 0 : model.size * Math.sin(Math.PI * rotationZ / 180),
+        translationZ: dir === "up" ? -0.05 * model.size : -0.5 * model.size
       }
     });
-    model.rotation.y += dir === "up" ? Math.PI + angle : angle;
-    const box = new THREE2.Box3().setFromObject(model);
-    const pivotPoint = dir === "up" ? new THREE2.Vector3(0, 0, 0) : new THREE2.Vector3(
-      1 * (box.min.x + box.max.x),
-      1 * (box.min.y + box.max.y),
-      0.6 * box.max.z
-    );
-    const pivot = new THREE2.Group();
-    pivot.add(model);
-    model.position.sub(pivotPoint);
-    model.updateMatrixWorld(true);
-    const altitude = f.properties.ordinal * HEIGHT_METER;
-    const baseObjectModel = this.threeLayer.toModel(pivot, {
-      coordinate,
-      altitude
-    });
-    this.threeLayer.addMesh(baseObjectModel);
-    return baseObjectModel;
+    escalatorMarker.addTo(this.gltfLayer);
+    return escalatorMarker;
   }
   async createTree(coordinate, ordinal) {
-    const model = await this.loadModel3d({
-      url: "https://dashboard.situm.com/uploads/3dmodels/demoaccount/arbol.glb",
-      properties: {
-        rotation: {
-          x: 0.5 * Math.PI,
-          // Rotate the model up (new_escalator.glb)
-          y: 0,
-          z: 0
-        },
-        position: { x: 0, y: 0, z: 0 },
-        scale: 0.01
+    const treeMarker = new maptalks4.GLTFMarker(coordinate, {
+      symbol: {
+        url: "https://dashboard.situm.com/uploads/3dmodels/demoaccount/new_escalator.glb"
       }
     });
-    const altitude = ordinal * HEIGHT_METER;
-    const baseObjectModel = this.threeLayer.toModel(model, {
-      coordinate,
-      altitude
-    });
-    this.threeLayer.addMesh(baseObjectModel);
-    return baseObjectModel;
+    treeMarker.addTo(this.gltfLayer);
+    return treeMarker;
+  }
+  async createBuilding(coordinate, ordinal) {
+    return Promise.resolve(null);
   }
   createElement(f) {
     switch (f.feature_type) {
@@ -3516,34 +3318,34 @@ var Element3DRenderer = class extends EventTarget {
       }
     });
   }
-  async loadModel3d(model3d) {
-    const loader = new GLTFLoader2();
-    loader.setDRACOLoader(this.dracoLoader);
-    const { url, properties: modelProperties } = model3d;
-    const gltf = await loader.loadAsync(url);
-    const model = gltf.scene;
-    model.rotation.x = modelProperties.rotation.x;
-    model.rotation.y = modelProperties.rotation.y;
-    model.position.x = modelProperties.position.x;
-    model.position.y = modelProperties.position.y;
-    model.position.z = modelProperties.position.z;
-    const scale2 = modelProperties.scale;
-    model.scale.set(scale2, scale2, scale2);
-    return model;
-  }
-  createMarker = (coordinates, ordinal, text) => {
-    const options = {
-      // scale: 0.05,
-      // altitude: ordinal * HEIGHT_METER,
-      text
-      // interactive: true,
-    };
-    const marker = new TextSpriteMarker(coordinates, options, this.threeLayer);
-    this.threeLayer.addMesh([marker]);
-    return marker;
-  };
-  removeMarker = () => {
-  };
+  createHighlightController(element) {
+    if (!(element instanceof BaseObject5)) {
+      return null;
+    }
+    switch (element.type) {
+      case "ExtrudePolygon": {
+        const mesh = element.getObject3d();
+        const originalMaterial = mesh.material;
+        const highlightMaterial = this.getOrCreateMaterialByColor("#ff0000");
+        return {
+          start: () => {
+            mesh.material = highlightMaterial;
+          },
+          clear: () => {
+            mesh.material = originalMaterial;
+          }
+        };
+      }
+      default: {
+        return {
+          start() {
+          },
+          clear() {
+          }
+        };
+      }
+    }
+  }
   render() {
     this.threeLayer._needsUpdate = !this.threeLayer._needsUpdate;
     if (this.threeLayer._needsUpdate) {
@@ -3651,7 +3453,10 @@ var Element2DRenderer = class extends EventTarget {
   async createEscalator(f, coordinates) {
     return Promise.resolve(null);
   }
-  async createTree(f, coordinates) {
+  async createTree(coordinates) {
+    return Promise.resolve(null);
+  }
+  async createBuilding(coordinate, ordinal) {
     return Promise.resolve(null);
   }
   createElement = (imdfFeature) => {
@@ -3671,6 +3476,15 @@ var Element2DRenderer = class extends EventTarget {
       element.hide();
     });
   }
+  createHighlightController(element) {
+    if (!(element instanceof maptalks5.Geometry)) return null;
+    return {
+      start() {
+      },
+      clear() {
+      }
+    };
+  }
 };
 
 // src/IndoorMap/renderer/2d/Marker2DRenderer.ts
@@ -3681,6 +3495,7 @@ var Marker2DRenderer = class extends EventTarget {
   markerLayer;
   constructor(map) {
     super();
+    this.map = map;
   }
   createMarker = (coordinates, ordinal, content) => {
     const marker = new maptalks6.ui.UIMarker(coordinates, {
@@ -3689,86 +3504,216 @@ var Marker2DRenderer = class extends EventTarget {
       collisionFadeIn: true,
       altitude: 0
     });
-    marker.addTo(this.map);
-    return marker;
-  };
-  removeMarker = (marker) => {
-    marker.remove();
-  };
-  showMarkers(elements, ordinalDiff = 0) {
+    marker.addTo(this.map);
+    return marker;
+  };
+  removeMarker = (marker) => {
+    marker.remove();
+  };
+  showMarkers(elements, ordinalDiff = 0) {
+  }
+  hideMarkers(elements, ordinalDiff = 0) {
+  }
+};
+
+// src/IndoorMap/renderer/3d/Marker3DRenderer.ts
+import * as maptalks7 from "maptalks-gl";
+
+// src/IndoorMap/renderer/3d/objects/TextSpriteMarker.ts
+import { Coordinate as Coordinate2, Util as Util4 } from "maptalks";
+import * as THREE2 from "three";
+import { BaseObject as BaseObject6 } from "maptalks.three";
+import { isNil, set } from "lodash";
+
+// src/IndoorMap/renderer/utils/interpolateStops.ts
+var interpolateStops = ({ stops }, zoom) => {
+  if (zoom <= stops[0][0]) return stops[0][1];
+  if (zoom >= stops[stops.length - 1][0]) return stops[stops.length - 1][1];
+  for (let i = 0; i < stops.length - 1; i++) {
+    const [z1, v1] = stops[i];
+    const [z2, v2] = stops[i + 1];
+    if (zoom >= z1 && zoom <= z2) {
+      const t = (zoom - z1) / (z2 - z1);
+      return v1 + t * (v2 - v1);
+    }
+  }
+};
+
+// src/IndoorMap/renderer/3d/objects/TextSpriteMarker.ts
+var OPTIONS4 = {
+  // Texture options
+  text: "",
+  textAlign: "center",
+  color: "#ffffff",
+  fontFamily: "sans-serif",
+  fontSize: 28,
+  fontWeight: 400,
+  background: "transparent",
+  lineHeight: 32,
+  padding: 8,
+  strokeColor: "#000000",
+  strokeWidth: 3,
+  strokeStyle: "round",
+  // Sprite options
+  /* Overall scale multiplier  */
+  scale: 1,
+  altitude: 0,
+  opacity: 1
+};
+var TextSpriteMarker = class extends BaseObject6 {
+  #altitudeOffset = 0;
+  constructor(coordinate, options, layer, properties = {}) {
+    options = Util4.extend({}, OPTIONS4, options, { layer });
+    super();
+    this._coordinate = new Coordinate2(coordinate);
+    this._initOptions(options);
+    this._createGroup();
+    this.properties = { ...properties };
+    const sprite = this._createSprite();
+    this.getObject3d().add(sprite);
+    this._updatePosition();
+    this.type = "TextSpriteMarker";
+  }
+  getOptions() {
+    return super.getOptions();
+  }
+  _createSprite() {
+    const options = this.getOptions();
+    const texture = this._createTextTexture(options.text, options);
+    const material = new THREE2.SpriteMaterial({
+      map: texture,
+      transparent: true,
+      alphaTest: 0.1
+    });
+    const sprite = new THREE2.Sprite(material);
+    const w = texture.image.width;
+    const h = texture.image.height;
+    const base = 1 / 16;
+    const normalizedScale = options.scale / this.getMap().getGLRes();
+    sprite.scale.set(w * base * normalizedScale, h * base * normalizedScale, 1);
+    this.#altitudeOffset = Math.max(
+      h * base * options.scale * 0.5,
+      0.05
+      // minimum lift in world units
+    );
+    return sprite;
+  }
+  _createTextTexture(text, options = {}) {
+    const {
+      padding,
+      fontSize,
+      fontFamily,
+      fontWeight,
+      lineHeight,
+      background,
+      color,
+      textAlign,
+      strokeColor,
+      strokeWidth,
+      maxWidth
+    } = options || {};
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    ctx.font = `${fontWeight} ${fontSize}px ${fontFamily}`;
+    const paragraphs = String(text).split("\n");
+    const wrappedLines = [];
+    paragraphs.forEach((paragraph) => {
+      if (isNil(maxWidth) || isNaN(maxWidth)) {
+        wrappedLines.push(paragraph);
+        return;
+      }
+      const words = paragraph.split(/\s+/);
+      let currentLine = "";
+      words.forEach((word) => {
+        const testLine = currentLine ? currentLine + " " + word : word;
+        const testWidth = ctx.measureText(testLine).width;
+        if (testWidth > maxWidth && currentLine) {
+          wrappedLines.push(currentLine);
+          currentLine = word;
+        } else {
+          currentLine = testLine;
+        }
+      });
+      if (currentLine) {
+        wrappedLines.push(currentLine);
+      }
+    });
+    const lines = wrappedLines.length ? wrappedLines : [""];
+    const widest = Math.max(...lines.map((l) => ctx.measureText(l).width), 0);
+    const finalWidth = (maxWidth ? Math.min(widest, maxWidth) : widest) + padding * 2;
+    const finalHeight = lineHeight * lines.length + padding * 2;
+    canvas.width = finalWidth;
+    canvas.height = finalHeight;
+    const ctx2 = canvas.getContext("2d");
+    ctx2.font = `${fontWeight} ${fontSize}px ${fontFamily}`;
+    ctx2.textAlign = textAlign;
+    if (background && background !== "transparent") {
+      ctx2.fillStyle = background;
+      ctx2.fillRect(0, 0, canvas.width, canvas.height);
+    }
+    lines.forEach((line, i) => {
+      const y = padding + lineHeight * (i + 0.8);
+      let x = padding;
+      if (textAlign === "center") x = canvas.width / 2;
+      if (textAlign === "right" || textAlign === "end")
+        x = canvas.width - padding;
+      if (strokeWidth > 0) {
+        ctx2.lineWidth = strokeWidth;
+        ctx2.lineJoin = "round";
+        ctx2.miterLimit = 2;
+        ctx2.strokeStyle = strokeColor;
+        ctx2.strokeText(line, x, y);
+      }
+      ctx2.fillStyle = color;
+      ctx2.fillText(line, x, y);
+    });
+    const texture = new THREE2.CanvasTexture(canvas);
+    texture.needsUpdate = true;
+    texture.minFilter = THREE2.LinearFilter;
+    return texture;
   }
-  hideMarkers(elements, ordinalDiff = 0) {
+  _updatePosition() {
+    const options = this.getOptions();
+    const layer = options.layer;
+    if (!layer) return;
+    const altitude = (options.altitude || 0) + this.#altitudeOffset;
+    const z = layer.altitudeToVector3(altitude, altitude).x;
+    const position = layer.coordinateToVector3(this._coordinate, z);
+    set(this.properties, "default.position", position);
+    this.getObject3d().position.copy(position);
   }
-};
-
-// src/IndoorMap/renderer/3d/Marker3DRenderer.ts
-import * as maptalks7 from "maptalks";
-
-// src/IndoorMap/renderer/utils/svg2material.ts
-import { SpriteMaterial as SpriteMaterial5, TextureLoader as TextureLoader3 } from "three";
-var svgToDataURL = (svgString, scaleFactor = 1) => {
-  const svgBlob = new Blob([svgString], { type: "image/svg+xml" });
-  const url = URL.createObjectURL(svgBlob);
-  const img = new Image();
-  return new Promise((resolve, reject) => {
-    img.onload = function() {
-      const newWidth = img.width * scaleFactor;
-      const newHeight = img.height * scaleFactor;
-      const canvas = document.createElement("canvas");
-      canvas.width = newWidth;
-      canvas.height = newHeight;
-      const ctx = canvas.getContext("2d");
-      ctx.drawImage(img, 0, 0, newWidth, newHeight);
-      const pngDataUrl = canvas.toDataURL("image/png");
-      resolve(pngDataUrl);
-    };
-    img.onerror = function(error) {
-      reject(error);
-    };
-    img.src = url;
-  });
-};
-var createSVGPathFromMarkerSymbol2 = (style) => {
-  const {
-    markerWidth = 24,
-    markerDx = 0,
-    markerDy = 0,
-    // markerFill,
-    markerPath,
-    fill = "#000000"
-  } = style;
-  const scale2 = markerWidth / 24;
-  const strokeWidth = 2;
-  const halfStrokeWidth = 0.5 * strokeWidth;
-  if (Array.isArray(markerPath)) {
-    return markerPath.map(
-      ({ path, fill: fill2 }) => `<path d="${path}" style="transform:translate(${markerDx}px, ${markerDy}px) scale(${scale2})" fill="${fill2}" stroke="#ffffff" stroke-width="${strokeWidth}" />`
-    );
+  _animation() {
+    const layer = this.getLayer();
+    if (!this.isAdd || !layer) return;
+    if (this._visible === true) {
+      const zoom = layer.map.getZoom();
+      const object3d = this.getObject3d();
+      const { opacity } = this.getOptions();
+      let opacityValue;
+      if (typeof opacity === "number") {
+        opacityValue = opacity ?? 1;
+      } else if (Array.isArray(opacity.stops)) {
+        opacityValue = interpolateStops(opacity, zoom);
+      } else {
+        throw new Error(`Unknown opacity value ${opacity}`);
+      }
+      const visible = opacityValue > 0.5;
+      object3d.visible = visible;
+    }
   }
-  return `<path d="${markerPath}" style="transform:translate(${markerDx}px, ${markerDy}px) scale(${scale2})" fill="${fill}" />`;
-};
-var createSpriteMaterialByLabelSymbol2 = (labelSymbol) => {
-  const material = new SpriteMaterial5();
-  try {
-    const [base, icon] = labelSymbol ?? [{}, {}];
-    const { markerWidth: baseWidth = 24 } = base;
-    const { markerWidth: iconWidth = 24 } = icon;
-    const viewBoxDimension = Math.max(baseWidth, iconWidth);
-    const baseSVG = createSVGPathFromMarkerSymbol2(base);
-    const iconSVG = icon ? createSVGPathFromMarkerSymbol2(icon) : "";
-    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${viewBoxDimension}" height="${viewBoxDimension}">${baseSVG}${iconSVG}</svg>`;
-    const textureLoader = new TextureLoader3();
-    const scaleFactor = 200 / 24;
-    svgToDataURL(svg, scaleFactor).then((png) => {
-      const texture = textureLoader.load(png, () => {
-        material.map = texture;
-        material.needsUpdate = true;
-      });
-    });
-  } catch (error) {
-    console.warn(`Error createSpriteMaterialByLabelSymbol: `, labelSymbol);
+  setText(text) {
+    const options = this.getOptions();
+    options.text = text;
+    const newSprite = this._createSprite();
+    const group = this.getObject3d();
+    group.children.forEach((child) => group.remove(child));
+    group.add(newSprite);
+    this._updatePosition();
+  }
+  setAltitude(altitude) {
+    const bottomHeight = this.options.bottomHeight ?? 0;
+    return super.setAltitude(altitude + bottomHeight + this.#altitudeOffset);
   }
-  return material;
 };
 
 // src/IndoorMap/renderer/3d/Marker3DRenderer.ts
@@ -3819,40 +3764,41 @@ var Marker3DRenderer = class extends EventTarget {
     });
   }
   /** Marker */
-  getOrCreateIconMaterial(key) {
-    if (!this.materialByKey) this.materialByKey = /* @__PURE__ */ new Map();
-    const existingMaterial = this.materialByKey.get(key);
-    if (existingMaterial) return existingMaterial;
-    const baseSymbol = {
-      markerType: "path",
-      markerPath: [
-        {
-          path: "M20.775 1.2H1.225V20.35H8.215L11.3 22.8L14.385 20.35H20.775V1.2Z",
-          fill: "#ff0000"
-        }
-      ],
-      markerPathWidth: 24,
-      markerPathHeight: 24
-    };
-    const markerSymbol = {
-      markerType: "path",
-      markerPath: [],
-      // TODO: Get Path by featureType.category
-      // markerPath: [{ fill: "#FFFFFF", path: "M 19 3 H 5 c -1.1 0 -2 0.9 -2 2 v 14 c 0 1.1 0.9 2 2 2 h 14 c 1.1 0 2 -0.9 2 -2 V 5 c 0 -1.1 -0.9 -2 -2 -2 Z m -2 6 h -1.7 l -5 9 H 7 c -0.83 0 -1.5 -0.67 -1.5 -1.5 S 6.17 15 7 15 h 1.7 l 5 -9 H 17 c 0.83 0 1.5 0.67 1.5 1.5 S 17.83 9 17 9 Z" }],
-      markerPathWidth: 24,
-      markerPathHeight: 24,
-      markerWidth: 24,
-      markerHeight: 24,
-      markerDy: 1.5,
-      markerDx: 1.5
-    };
-    const created = createSpriteMaterialByLabelSymbol2([
-      baseSymbol,
-      markerSymbol
-    ]);
-    this.materialByKey.set(key, created);
-    return created;
-  }
+  // getOrCreateIconMaterial(key) {
+  //   if (!this.materialByKey) this.materialByKey = new Map()
+  //   const existingMaterial = this.materialByKey.get(key)
+  //   if (existingMaterial) return existingMaterial
+  //   // Create new
+  //   const baseSymbol: maptalks.Path = {
+  //     markerType: "path",
+  //     markerPath: [
+  //       {
+  //         path: "M20.775 1.2H1.225V20.35H8.215L11.3 22.8L14.385 20.35H20.775V1.2Z",
+  //         fill: "#ff0000",
+  //       },
+  //     ],
+  //     markerPathWidth: 24,
+  //     markerPathHeight: 24
+  //   }
+  //   const markerSymbol: maptalks.PathMarkerSymbol = {
+  //     markerType: "path",
+  //     markerPath: [],
+  //     // TODO: Get Path by featureType.category
+  //     // markerPath: [{ fill: "#FFFFFF", path: "M 19 3 H 5 c -1.1 0 -2 0.9 -2 2 v 14 c 0 1.1 0.9 2 2 2 h 14 c 1.1 0 2 -0.9 2 -2 V 5 c 0 -1.1 -0.9 -2 -2 -2 Z m -2 6 h -1.7 l -5 9 H 7 c -0.83 0 -1.5 -0.67 -1.5 -1.5 S 6.17 15 7 15 h 1.7 l 5 -9 H 17 c 0.83 0 1.5 0.67 1.5 1.5 S 17.83 9 17 9 Z" }],
+  //     markerPathWidth: 24,
+  //     markerPathHeight: 24,
+  //     markerWidth: 24,
+  //     markerHeight: 24,
+  //     markerDy: 1.5,
+  //     markerDx: 1.5,
+  //   }
+  //   const created = createSpriteMaterialByLabelSymbol([
+  //     baseSymbol,
+  //     markerSymbol,
+  //   ])
+  //   this.materialByKey.set(key, created)
+  //   return created
+  // }
 };
 
 // src/IndoorMap/renderer/utils/angleBetweenLineString.ts
@@ -3874,11 +3820,17 @@ var angleBetweenLineStrings = (line1, line2) => {
 };
 
 // src/IndoorMap/renderer/RendererManager.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 var RendererManager = class extends EventTarget {
   map;
   options;
   // Client for fetching data
   #dataClient;
+  #isClicked = false;
+  #onClickElement = (e) => {
+  };
   /** Elements: Responsible for converting feature info elements and add to map */
   elementRenderer;
   markerRenderer;
@@ -3887,6 +3839,7 @@ var RendererManager = class extends EventTarget {
   currentOrdinals;
   markersMap;
   markersByOrdinal;
+  highlightControllers = [];
   constructor(map, dataClient, options) {
     super();
     this.map = map;
@@ -3896,48 +3849,52 @@ var RendererManager = class extends EventTarget {
     this.markersMap = /* @__PURE__ */ new Map();
     this.markersByOrdinal = /* @__PURE__ */ new Map();
     this.#dataClient = dataClient;
+    const _this = this;
     if (options.type === "3D") {
-      const threeLayer = new ThreeLayer3("elements", {
-        forceRenderOnMoving: true,
-        forceRenderOnRotating: true
-      });
-      const _this = this;
+      const groupLayer = this.map.getLayer("group");
+      const threeLayer = groupLayer.getLayer("three");
       threeLayer.prepareToDraw = function(gl, scene, camera) {
         const ambientLight = new THREE3.AmbientLight(16777215, 0.3);
         scene.add(ambientLight);
         const dirColor = 16777215;
         const dllight = new THREE3.DirectionalLight(dirColor, 0.8);
-        dllight.position.set(0, -10, 10).normalize();
+        dllight.position.set(0, -10, 20).normalize();
         scene.add(dllight);
         const hemi = new THREE3.HemisphereLight(16777215, 4473924, 0.4);
         scene.add(hemi);
-        _this.elementRenderer = new Element3DRenderer(map, options.elements, threeLayer);
+        _this.elementRenderer = new Element3DRenderer(map, options.elements);
         _this.markerRenderer = new Marker3DRenderer(map, {}, threeLayer);
         if (typeof options.onRendererReady === "function") {
           options.onRendererReady();
         }
         _this.#createElements();
       };
-      threeLayer.addTo(this.map);
     } else {
       this.elementRenderer = new Element2DRenderer(map, options.elements);
       this.markerRenderer = new Marker2DRenderer(map);
       this.#createElements();
     }
   }
+  set onClickElement(func) {
+    this.#onClickElement = func;
+  }
+  handleClickElement = (e) => {
+    if (this.#isClicked) return;
+    this.#isClicked = true;
+    const onClickElement = this.#onClickElement;
+    if (!_isFunction(onClickElement)) return;
+    this.#onClickElement(e);
+    this.#isClicked = false;
+  };
   getElementsByOrdinal = (ordinal) => {
     const exist = this.elementsByOrdinal.get(ordinal);
     if (!exist) this.elementsByOrdinal.set(ordinal, []);
     return this.elementsByOrdinal.get(ordinal);
   };
-  getMarkersByOrdinal = (ordinal) => {
-    const exist = this.markersByOrdinal.get(ordinal);
-    if (!exist) this.markersByOrdinal.set(ordinal, []);
-    return this.markersByOrdinal.get(ordinal);
-  };
   addElementsToManager = (id, elements, ordinal) => {
     this.elementsMap.set(id, elements);
     elements.forEach((el) => {
+      el.on("click", (e) => this.handleClickElement(id));
       this.getElementsByOrdinal(ordinal).push(el);
     });
     const inOrdinal = Array.isArray(this.currentOrdinals) ? this.currentOrdinals.includes(ordinal) : ordinal === this.currentOrdinals;
@@ -3947,19 +3904,8 @@ var RendererManager = class extends EventTarget {
       this.elementRenderer.hideElements(elements, ordinal);
     }
   };
-  addMarkersToManager = (id, markers, ordinal) => {
-    this.markersMap.set(id, markers);
-    markers.forEach((el) => {
-      this.getMarkersByOrdinal(ordinal).push(el);
-    });
-    const inOrdinal = Array.isArray(this.currentOrdinals) ? this.currentOrdinals.includes(ordinal) : ordinal === this.currentOrdinals;
-    if (inOrdinal) {
-      this.markerRenderer.showMarkers(markers, ordinal);
-    } else {
-      this.markerRenderer.hideMarkers(markers, ordinal);
-    }
-  };
   async #createElements() {
+    await delay(this.options.delayBeforeCreateElements ?? 0);
     const levels = await this.#dataClient.filterByType("level", {
       populate: true
     });
@@ -4006,13 +3952,15 @@ var RendererManager = class extends EventTarget {
         }
         const thisOrdinal = escalator.properties.ordinal;
         const relationship = escalatorRelationships[0];
+        if (!relationship.properties.origin?.id) throw new Error(`relationship (id=${relationship.id}) - origin not exists`);
+        if (!relationship.properties.destination?.id) throw new Error(`relationship (id=${relationship.id}) - destination not exists`);
         const bothOpeningIds = [relationship.properties.origin.id, relationship.properties.destination.id];
         const bothOpenings = await Promise.all(
           bothOpeningIds.map((id) => this.#dataClient.findById("opening", id, { populate: true }))
         );
         const thisLevelOpening = bothOpenings.find((opening) => opening.properties.ordinal === thisOrdinal);
         const thatLevelOpening = bothOpenings.find((opening) => opening.properties.ordinal !== thisOrdinal);
-        const angle = angleBetweenLineStrings(thisLevelOpening.geometry.coordinates, thatLevelOpening.geometry.coordinates);
+        const angle = 180 * (1 / Math.PI) * angleBetweenLineStrings(thisLevelOpening.geometry.coordinates, thatLevelOpening.geometry.coordinates);
         const direction = thisOrdinal < thatLevelOpening.properties.ordinal ? "up" : "down";
         const escalatorEntryPoint = turfCenter2(thisLevelOpening).geometry.coordinates;
         const element = await this.elementRenderer.createEscalator(escalator, escalatorEntryPoint, { direction, angle });
@@ -4021,7 +3969,7 @@ var RendererManager = class extends EventTarget {
           this.addElementsToManager(escalator.id, _elements, escalator.properties.ordinal);
         }
       } catch (err) {
-        console.log(`cannot create escalator`, err);
+        console.warn(`cannot create escalator`, err.message);
       }
     }
     this.changeLevelByOrdinal(this.currentOrdinals);
@@ -4057,14 +4005,48 @@ var RendererManager = class extends EventTarget {
       }
     }
   }
+  highlightElements = (elemIds, options) => {
+    const { reset = true } = options ?? {};
+    if (reset) {
+      this.clearHighlightElements();
+    }
+    const elements = elemIds.map((id) => this.elementsMap.get(id)).flat();
+    elements.forEach((element) => {
+      const controller = this.elementRenderer.createHighlightController(element);
+      controller.start();
+      this.highlightControllers.push(controller);
+    });
+  };
+  clearHighlightElements = () => {
+    this.highlightControllers.forEach((controller) => {
+      if (_isFunction(controller?.clear)) controller.clear();
+    });
+  };
   /** 
    * ========================================================================
    * Markers
    * ======================================================================== */
+  _getMarkersByOrdinal = (ordinal) => {
+    const exist = this.markersByOrdinal.get(ordinal);
+    if (!exist) this.markersByOrdinal.set(ordinal, []);
+    return this.markersByOrdinal.get(ordinal);
+  };
+  _addMarkersToManager = (id, markers, ordinal) => {
+    this.markersMap.set(id, markers);
+    markers.forEach((el) => {
+      this._getMarkersByOrdinal(ordinal).push(el);
+    });
+    const inOrdinal = Array.isArray(this.currentOrdinals) ? this.currentOrdinals.includes(ordinal) : ordinal === this.currentOrdinals;
+    if (inOrdinal) {
+      this.markerRenderer.showMarkers(markers, ordinal);
+    } else {
+      this.markerRenderer.hideMarkers(markers, ordinal);
+    }
+  };
   createMarker(coordinate, ordinal, text, options) {
     const marker = this.markerRenderer.createMarker(coordinate, ordinal, text, options);
     const markerId = `${this.markersMap.size + 1}`;
-    this.addMarkersToManager(markerId, [marker], ordinal);
+    this._addMarkersToManager(markerId, [marker], ordinal);
   }
   clearMarkers() {
     for (const [markerId, marker] of this.markersMap) {
@@ -4082,6 +4064,7 @@ var defaultOptions = {
   locale: DEFAULT_LOCALE
 };
 var IndoorMap = class extends EventTarget {
+  options;
   //TODO: refac functions; let them do only 1 thing in a function
   /** Note: "#" means private variables */
   #styler = null;
@@ -4133,14 +4116,18 @@ var IndoorMap = class extends EventTarget {
   };
   constructor(elementId, options) {
     super();
+    const combinedOptions = _6.merge({}, defaultOptions, options);
+    this.options = options;
     const {
       onMapReady,
       onMapLoading,
       pixelRatio,
       locale
-    } = _6.merge({}, defaultOptions, options);
+    } = combinedOptions;
     this.map = new Map2(elementId, {
       attribution: false,
+      // Temporart set, not really default view
+      // Default view is set in camera manager
       center: INITIAL_CENTER,
       zoom: INITIAL_ZOOM,
       clickTimeThreshold: 600,
@@ -4156,8 +4143,16 @@ var IndoorMap = class extends EventTarget {
       }),
       layers: []
     });
+    const groupLayer = new GroupGLLayer("group", [], {}).addTo(this.map);
+    const threeLayer = new ThreeLayer4("three", {
+      forceRenderOnMoving: true,
+      forceRenderOnRotating: true
+    });
+    groupLayer.addLayer(threeLayer);
+    const gltfLayer = new GLTFLayer("gltf");
+    groupLayer.addLayer(gltfLayer);
     this.rendererManager = new RendererManager(this.map, options.dataClient, options.renderer);
-    this.camera = new CameraManager(this.map);
+    this.camera = new CameraManager(this.map, options.camera);
     this.locale = locale;
     this.pixelRatio = pixelRatio;
     this.onMapReady = onMapReady;
@@ -4168,19 +4163,21 @@ var IndoorMap = class extends EventTarget {
   }
   set dataClient(value) {
     this.#dataClient = value;
-    this.#dataClient.filterByType("venue").then((venues) => {
-      const venueCenters = turfCenter3(featureCollection(venues));
-      const [x, y] = venueCenters.geometry.coordinates;
-      const center2 = new Coordinate4(x, y);
-      this.camera.setView({ center: center2, pitch: 60, zoom: 19 });
-    });
-  }
-  on(eventName, handler) {
-    this.map.on(eventName, handler);
+    if (!this.options.camera?.defaultView?.center) {
+      this.#dataClient.filterByType("venue").then((venues) => {
+        const venueCenters = turfCenter3(featureCollection(venues));
+        const [x, y] = venueCenters.geometry.coordinates;
+        const center2 = new Coordinate4(x, y);
+        this.camera.setView({ center: center2, pitch: 60, zoom: 19 });
+      });
+    }
   }
   /**
    * Events
    */
+  on(eventName, handler) {
+    this.map.on(eventName, handler);
+  }
   handleMapClick = ({ coordinate }) => {
     const { x, y } = coordinate;
     console.log(
@@ -4236,40 +4233,12 @@ var IndoorMap = class extends EventTarget {
       this.map.off("moveend", this.#findAndSetVenueInView);
     }
   }
-  get ordinals() {
-    return this.#ordinals || [];
-  }
-  set ordinals(value) {
-    if (!Array.isArray(value)) throw new Error("ordinals must be Array");
-    this.#ordinals = value;
-  }
   set billboards(value) {
     this.#billboards = value;
   }
-  set mapConfig(value) {
-    this.#mapConfig = value;
-  }
   set mapDecorations(value) {
     this.#mapDecorations = value;
   }
-  set maxZoom(value) {
-    this.map.setMaxZoom(value);
-    const spatialReference = {
-      projection: "EPSG:3857",
-      resolutions: (function() {
-        const resolutions = [];
-        const d = 2 * 6378137 * Math.PI;
-        for (let i = 0; i < value; i++) {
-          resolutions[i] = d / (256 * Math.pow(2, i));
-        }
-        return resolutions;
-      })()
-    };
-    this.map.setSpatialReference(spatialReference);
-  }
-  set minZoom(value) {
-    this.map.setMinZoom(value);
-  }
   set groundLabels(value) {
     this.#groundLabels = value;
   }
@@ -4277,7 +4246,7 @@ var IndoorMap = class extends EventTarget {
     this.map.setDevicePixelRatio(value);
   }
   set onClickElement(func) {
-    this.#onClickElement = func;
+    this.rendererManager.onClickElement = func;
   }
   set locale(value) {
     this.#locale = value || defaultOptions.locale;
@@ -4305,9 +4274,6 @@ var IndoorMap = class extends EventTarget {
     this.#onClickElement(e);
     this.#isClicked = false;
   };
-  setCenter(center2, padding) {
-    this.map.setCenter(center2, padding);
-  }
   async #legacy_createElements() {
     const {
       // 2D
@@ -4321,33 +4287,14 @@ var IndoorMap = class extends EventTarget {
       create3DFootprint,
       create3DGroundLabel,
       create3DBillboard,
-      createVenue3DModel,
       createExtrudedUnit,
-      create3DFixture,
       create3DAmenityMarker,
       create3DOccupantAmenityMarker,
       create3DOpeningMarker,
-      createOccupantGroundLabel,
-      // Light
-      createAmbientLight,
-      createDirectionalLight
+      createOccupantGroundLabel
     } = this.#styler;
     let elements = {};
     let object3ds = [];
-    const scene = this.threeLayer.getScene();
-    if (scene) {
-      const {
-        ambientLight: ambientLightConfig = {},
-        directionalLight: directionalLightConfig = {}
-      } = _6.get(this.#mapConfig, "light", {
-        ambientLight: {},
-        directionalLight: {}
-      });
-      const ambientLight = createAmbientLight(ambientLightConfig);
-      scene.add(ambientLight);
-      const light = createDirectionalLight(directionalLightConfig);
-      scene.add(light);
-    }
     for (const feature2 of this.#features) {
       try {
         const { feature_type: featureType, properties, id } = feature2;
@@ -4370,16 +4317,6 @@ var IndoorMap = class extends EventTarget {
           feature2
         );
         switch (featureType) {
-          case "venue": {
-            geometry = createVenue(feature2).addTo(layer);
-            const models = await createVenue3DModel(feature2, this.threeLayer);
-            models.forEach((model) => {
-              model.on("click", this.handleClickElement);
-              object3ds.push(model);
-              this.#venueObjects.push(model);
-            });
-            break;
-          }
           case "amenity": {
             if (feature2.properties.is_featured) {
               const billboardObj = create3DBillboard(feature2, this.threeLayer);
@@ -4423,127 +4360,6 @@ var IndoorMap = class extends EventTarget {
             geometry = createSection(feature2)?.addTo(layer);
             break;
           }
-          case "occupant": {
-            switch (category) {
-              // Create only marker if it is amenity occupant
-              case "currencyexchange":
-              case "donationcenter":
-              case "postoffice":
-                const markerFeature = {
-                  ...feature2,
-                  geometry: feature2.properties?.anchor?.geometry
-                };
-                const marker3d = create3DOccupantAmenityMarker(
-                  markerFeature,
-                  this.threeLayer,
-                  extrudeConfig
-                )?.on("click", this.handleClickElement);
-                object3ds.push(marker3d);
-                break;
-              default: {
-                const { kiosk, anchor } = feature2.properties;
-                const { unit } = anchor.properties;
-                let mainLocation = kiosk || unit || null;
-                const relatedLocations = [
-                  ...feature2.properties.units,
-                  ...feature2.properties.kiosks
-                ].filter((f) => f.properties.ordinal !== properties.ordinal);
-                const occupantLocations = [mainLocation, ...relatedLocations];
-                const renderType = feature2.properties.render_type;
-                occupantLocations.forEach((location, index) => {
-                  const isMainLocation = index === 0;
-                  if (renderType === "Label") {
-                    const occupantGroundLabel = createOccupantGroundLabel(
-                      feature2,
-                      location,
-                      { textMarkerType, extrudeConfig },
-                      this.threeLayer
-                    );
-                    if (occupantGroundLabel instanceof GroundLabel) {
-                      occupantGroundLabel.on("click", this.handleClickElement);
-                      occupantGroundLabel.addTo(this.threeLayer);
-                      object3ds.push(occupantGroundLabel);
-                      this.#groundObjects.push(occupantGroundLabel);
-                    }
-                  } else {
-                    const occupantMarker = createOccupant(feature2, location, {
-                      textMarkerType,
-                      extrudeConfig
-                    });
-                    if (occupantMarker instanceof ui3.UIMarker) {
-                      occupantMarker.addTo(this.map);
-                    } else {
-                      occupantMarker?.on("click", this.handleClickElement);
-                      occupantMarker?.addTo(layer);
-                    }
-                    if (isMainLocation) {
-                      geometry = occupantMarker;
-                    } else {
-                      elements[`${feature2.id}_${index}`] = {
-                        geometry: occupantMarker,
-                        properties: location.properties,
-                        featureType: "occupant",
-                        feature: feature2
-                      };
-                    }
-                  }
-                });
-              }
-            }
-            break;
-          }
-          case "fixture": {
-            const models = await create3DFixture(feature2, this.threeLayer);
-            models.forEach((model) => {
-              model.on("click", this.handleClickElement);
-              object3ds.push(model);
-              this.#glbObjects.push(model);
-            });
-            if (!featureExtrudeConfig) {
-              geometry = createFixture(feature2)?.addTo(layer);
-            } else {
-              const locatedLevel = feature2?.properties?.level;
-              const levelExtrudeConfig = getExtrudeConfigByFeature(
-                extrudeConfig,
-                locatedLevel
-              );
-              const levelHeight = _6.get(levelExtrudeConfig, "height", 0);
-              const option = { ...featureExtrudeConfig, altitude: levelHeight };
-              const extrudedFixture = createExtrudedUnit(
-                feature2,
-                this.threeLayer,
-                option
-              );
-              object3ds.push(extrudedFixture);
-            }
-            break;
-          }
-          case "footprint": {
-            const objects = await create3DFootprint(
-              feature2,
-              this.threeLayer,
-              featureExtrudeConfig
-            );
-            objects.forEach((object) => {
-              object.on("click", () => {
-                const {
-                  geometry: { coordinates }
-                } = turfCenter3(feature2);
-                this.camera.flyToAndZoomIn(coordinates, { pitch: 45 });
-              });
-              object3ds.push(object);
-              this.#objects.push(object);
-            });
-            if (feature2.properties.logo) {
-              const footprintMarker = create3DBillboard(
-                feature2,
-                this.threeLayer
-              );
-              object3ds.push(footprintMarker);
-              this.#billboardObjects.push(footprintMarker);
-            }
-            break;
-          }
           default:
             break;
         }
@@ -4612,27 +4428,6 @@ var IndoorMap = class extends EventTarget {
   changeLevelByOrdinal(ordinal) {
     this.rendererManager.changeLevelByOrdinal(ordinal);
   }
-  getFeatureExtent = (feature2, scaleFactor = 1) => {
-    const [minX, minY, maxX, maxY] = index_default(
-      scale(bboxPolygon(index_default(feature2)), scaleFactor)
-    );
-    return new Extent(minX, minY, maxX, maxY);
-  };
-  getExtentCenter = (extent) => {
-    return extent.getCenter();
-  };
-  getExtentZoom = (extent, options = {
-    isFraction: false,
-    padding: {
-      paddingLeft: 0,
-      paddingRight: 0,
-      paddingTop: 0,
-      paddingBottom: 0
-    }
-  }) => {
-    const { isFraction = false, padding } = options;
-    return this.map.getFitZoom(extent, isFraction, padding);
-  };
   findVenueInView = () => {
     const mapCenter = this.map.getCenter();
     const result = this.#venues.reduce((closest, venue) => {
@@ -4645,9 +4440,6 @@ var IndoorMap = class extends EventTarget {
     }, null);
     return result;
   };
-  flyTo = (center2, options) => {
-    this.camera.flyTo(center2, options);
-  };
   getLineStringBearing = (feature2) => {
     const { geometry } = feature2;
     const path = new LineString3(geometry.coordinates);
@@ -5163,33 +4955,6 @@ var IndoorMap = class extends EventTarget {
   /**
    * render (frame)
    */
-  getTargetViewCenter = (targetView, options = { offset: { top: 0, left: 0, right: 0, bottom: 0 } }) => {
-    const map = this.map;
-    const { offset } = options;
-    const { top = 0, left = 0, right = 0, bottom = 0 } = offset;
-    const originalState = {
-      bearing: map.getBearing(),
-      center: map.getCenter(),
-      pitch: map.getPitch(),
-      zoom: map.getZoom()
-    };
-    const finalView = {
-      bearing: _6.isNil(targetView.bearing) ? map.getBearing() : targetView.bearing,
-      center: _6.isNil(targetView.center) ? map.getCenter() : targetView.center,
-      pitch: _6.isNil(targetView.pitch) ? map.getPitch() : targetView.pitch,
-      zoom: _6.isNil(targetView.zoom) ? map.getZoom() : targetView.zoom
-    };
-    map.setView(finalView);
-    const projectedTargetCenter = map.coordinateToContainerPoint(finalView.center).add(right / 2 - left / 2, bottom / 2 - top / 2);
-    const adjustedTargetCenter = map.containerPointToCoordinate(
-      projectedTargetCenter
-    );
-    map.setView(originalState);
-    return adjustedTargetCenter;
-  };
-  setMaxExtent(extent) {
-    return this.map.setMaxExtent(extent);
-  }
   render() {
     const view = this.map.getView();
     const currBearing = view.bearing;
@@ -5198,7 +4963,8 @@ var IndoorMap = class extends EventTarget {
       this.threeLayer.redraw();
     }
     if (this.threeLayer) {
-      const objectOpacity = _6.clamp(38 - 2 * this.camera.getZoom(), 0, 1);
+      const currentView = this.camera.getView();
+      const objectOpacity = _6.clamp(38 - 2 * currentView.zoom, 0, 1);
       this.#objects.forEach((object) => {
         object.getObject3d().traverse((child) => {
           if (child.isMesh) child.material.opacity = objectOpacity;
@@ -5209,7 +4975,7 @@ var IndoorMap = class extends EventTarget {
       if (this.#billboardObjects) {
         this.#billboardObjects.forEach((object) => {
           const objectScale = _6.clamp(
-            20 - 1 * this.camera.getZoom(),
+            20 - 1 * currentView.zoom,
             1,
             1.05
           );
@@ -5261,6 +5027,7 @@ export {
   MARKER_LAYER_NAME,
   NONIMDF_FEATURE_TYPES,
   ORIGIN_MARKER_ID,
+  occupant_helper_exports as OccupantHelpers,
   POI_MARKER_LAYER_NAME,
   QueryObserver2 as QueryObserver,
   USER_LOCATION_ELEMENT_ID,
@@ -5288,6 +5055,16 @@ export {
   getRelatedLocationsByOccupant,
   getSuitablyValueBetweenBearings,
   isClickableFeature,
+  isValidCoordinate,
+  isValidLineString,
+  isValidLineStringCoordinates,
+  isValidMultiPolygon,
+  isValidMultiPolygonCoordinates,
+  isValidPoint,
+  isValidPolygon,
+  isValidPolygonCoordinates,
+  matchFilter,
+  matchFilters,
   safeFetchFeature,
   styledFeatureGenerator
 };