@mappedin/dynamic-focus 6.0.1-beta.61 → 6.0.1-beta.62

package/lib/esm/chunk-RSECYADN.js

@@ -1,1175 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// <define:process>
-var define_process_default = { env: { npm_package_version: "6.0.1-beta.61" } };
-
-// src/dynamic-focus.ts
-import { Floor as Floor3, getMultiFloorState as getMultiFloorState2 } from "@mappedin/mappedin-js";
-
-// ../packages/common/array-utils.ts
-function arraysEqual(arr1, arr2) {
-  if (arr1 == null || arr2 == null) {
-    return arr1 === arr2;
-  }
-  if (arr1.length !== arr2.length) {
-    return false;
-  }
-  for (let i = 0; i < arr1.length; i++) {
-    if (arr1[i] !== arr2[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-__name(arraysEqual, "arraysEqual");
-
-// ../packages/common/pubsub.ts
-var PubSub = class {
-  static {
-    __name(this, "PubSub");
-  }
-  /**
-   * @private
-   * @internal
-   */
-  _subscribers = {};
-  /**
-   * @private
-   * @internal
-   */
-  _destroyed = false;
-  /**
-   * @private
-   * @internal
-   */
-  publish(eventName, data) {
-    if (!this._subscribers || !this._subscribers[eventName] || this._destroyed) {
-      return;
-    }
-    this._subscribers[eventName].forEach(function(fn) {
-      if (typeof fn !== "function") {
-        return;
-      }
-      fn(data);
-    });
-  }
-  /**
-   * Subscribe a function to an event.
-   *
-   * @param eventName An event name which, when fired, will call the provided
-   * function.
-   * @param fn A callback that gets called when the corresponding event is fired. The
-   * callback will get passed an argument with a type that's one of event payloads.
-   * @example
-   * // Subscribe to the 'click' event
-   * const handler = (event) => {
-   *  const { coordinate } = event;
-   *  const { latitude, longitude } = coordinate;
-   * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
-   * };
-   * map.on('click', handler);
-   */
-  on(eventName, fn) {
-    if (!this._subscribers || this._destroyed) {
-      this._subscribers = {};
-    }
-    this._subscribers[eventName] = this._subscribers[eventName] || [];
-    this._subscribers[eventName].push(fn);
-  }
-  /**
-   * Unsubscribe a function previously subscribed with {@link on}
-   *
-   * @param eventName An event name to which the provided function was previously
-   * subscribed.
-   * @param fn A function that was previously passed to {@link on}. The function must
-   * have the same reference as the function that was subscribed.
-   * @example
-   * // Unsubscribe from the 'click' event
-   * const handler = (event) => {
-   * 	console.log('Map was clicked', event);
-   * };
-   * map.off('click', handler);
-   */
-  off(eventName, fn) {
-    if (!this._subscribers || this._subscribers[eventName] == null || this._destroyed) {
-      return;
-    }
-    const itemIdx = this._subscribers[eventName].indexOf(fn);
-    if (itemIdx !== -1) {
-      this._subscribers[eventName].splice(itemIdx, 1);
-    }
-  }
-  /**
-   * @private
-   * @internal
-   */
-  destroy() {
-    this._destroyed = true;
-    this._subscribers = {};
-  }
-};
-
-// src/building.ts
-import { Facade, Floor, FloorStack } from "@mappedin/mappedin-js";
-var Building = class {
-  static {
-    __name(this, "Building");
-  }
-  __type = "building";
-  #floorStack;
-  #floorsById = /* @__PURE__ */ new Map();
-  #floorsByElevation = /* @__PURE__ */ new Map();
-  #floorsByElevationSorted = [];
-  #mapView;
-  #animationInProgress;
-  defaultFloor;
-  activeFloor;
-  excluded = false;
-  floorsAltitudesMap = /* @__PURE__ */ new Map();
-  aboveGroundFloors = [];
-  constructor(floorStack, mapView) {
-    this.#floorStack = floorStack;
-    this.#floorsById = new Map(floorStack.floors.map((floor) => [floor.id, floor]));
-    this.#floorsByElevation = new Map(floorStack.floors.map((floor) => [floor.elevation, floor]));
-    this.#floorsByElevationSorted = Array.from(this.#floorsByElevation.values()).sort(
-      (a, b) => a.elevation - b.elevation
-    );
-    this.defaultFloor = floorStack.defaultFloor;
-    this.activeFloor = this.defaultFloor;
-    this.#mapView = mapView;
-    this.aboveGroundFloors = this.#floorsByElevationSorted.filter((floor) => floor.elevation >= 0);
-    const sortedSpaces = floorStack.facade?.spaces.map((space) => this.#mapView.getState(space)).sort((a, b) => a.altitude - b.altitude);
-    if (sortedSpaces && sortedSpaces.length === this.aboveGroundFloors.length) {
-      for (const idx in this.aboveGroundFloors) {
-        const floor = this.aboveGroundFloors[idx];
-        const space = sortedSpaces[idx];
-        this.floorsAltitudesMap.set(floor.elevation, {
-          altitude: space.altitude,
-          effectiveHeight: space.height
-        });
-      }
-    }
-  }
-  get id() {
-    return this.#floorStack.id;
-  }
-  get name() {
-    return this.#floorStack.name;
-  }
-  get floors() {
-    return this.#floorStack.floors;
-  }
-  get floorStack() {
-    return this.#floorStack;
-  }
-  get facade() {
-    return this.#floorStack.facade;
-  }
-  get isCurrentFloorStack() {
-    return this.id === this.#mapView.currentFloorStack.id;
-  }
-  get isIndoor() {
-    const state = this.#mapView.getState(this.facade);
-    return this.isCurrentFloorStack || state?.visible === false && state?.opacity === 0;
-  }
-  get canSetFloor() {
-    return this.isIndoor || !this.excluded;
-  }
-  #maxElevation;
-  get maxElevation() {
-    if (this.#maxElevation == null) {
-      this.#maxElevation = Math.max(...this.#floorsByElevation.keys());
-    }
-    return this.#maxElevation;
-  }
-  #minElevation;
-  get minElevation() {
-    if (this.#minElevation == null) {
-      this.#minElevation = Math.min(...this.#floorsByElevation.keys());
-    }
-    return this.#minElevation;
-  }
-  has(f) {
-    if (Floor.is(f)) {
-      return this.#floorsById.has(f.id);
-    }
-    if (FloorStack.is(f)) {
-      return f.id === this.#floorStack.id;
-    }
-    if (Facade.is(f)) {
-      return f.id === this.facade.id;
-    }
-    return false;
-  }
-  getFloorByElevation(elevation) {
-    return this.#floorsByElevation.get(elevation);
-  }
-  getNearestFloorByElevation(targetElevation) {
-    const exactMatch = this.getFloorByElevation(targetElevation);
-    if (exactMatch) {
-      return exactMatch;
-    }
-    if (targetElevation >= 0) {
-      if (targetElevation > this.maxElevation) {
-        return this.#floorsByElevationSorted[this.#floorsByElevationSorted.length - 1];
-      }
-      for (let i = this.#floorsByElevationSorted.length - 1; i >= 0; i--) {
-        const floor = this.#floorsByElevationSorted[i];
-        if (floor.elevation <= targetElevation) {
-          return floor;
-        }
-      }
-    } else {
-      if (targetElevation < this.minElevation) {
-        return this.#floorsByElevationSorted[0];
-      }
-      for (const floor of this.#floorsByElevationSorted) {
-        if (floor.elevation >= targetElevation) {
-          return floor;
-        }
-      }
-    }
-    return void 0;
-  }
-  getHighestFloor() {
-    return this.#floorsByElevationSorted[this.#floorsByElevationSorted.length - 1];
-  }
-  cancelAnimation() {
-    if (this.#animationInProgress) {
-      this.#animationInProgress.animation.cancel();
-      this.#animationInProgress = void 0;
-    }
-  }
-  async animateFacade(newState, options = { duration: 150 }) {
-    const currentState = this.#animationInProgress?.state || this.#mapView.getState(this.facade);
-    if (!currentState || !newState || currentState?.opacity === newState.opacity && currentState?.visible === newState.visible) {
-      return { result: "completed" };
-    }
-    this.cancelAnimation();
-    const { opacity, visible } = newState;
-    this.#mapView.updateState(this.facade, {
-      visible: true
-    });
-    if (opacity !== void 0) {
-      this.#animationInProgress = {
-        animation: this.#mapView.animateState(
-          this.facade,
-          {
-            opacity
-          },
-          {
-            duration: options.duration
-          }
-        ),
-        state: newState
-      };
-      const result = await this.#animationInProgress.animation;
-      this.#animationInProgress = void 0;
-      if (result.result === "cancelled") {
-        return result;
-      }
-    }
-    if (visible === false) {
-      this.#mapView.updateState(this.facade, {
-        visible
-      });
-    }
-    return { result: "completed" };
-  }
-  destroy() {
-    this.cancelAnimation();
-    this.#floorStack.floors.forEach((floor) => {
-      this.#mapView.updateState(floor, {
-        visible: floor.id === this.#mapView.currentFloor.id
-      });
-    });
-    if (!this.has(this.#mapView.currentFloor)) {
-      this.#mapView.updateState(this.facade, {
-        visible: true,
-        opacity: 1
-      });
-    }
-  }
-};
-
-// src/dynamic-focus-scene.ts
-function getZoomState(zoomLevel, indoorThreshold, outdoorThreshold) {
-  if (zoomLevel >= indoorThreshold) {
-    return "in-range";
-  }
-  if (zoomLevel <= outdoorThreshold) {
-    return "out-of-range";
-  }
-  return "transition";
-}
-__name(getZoomState, "getZoomState");
-function getFloorToShow(target, mode, elevation) {
-  if (target.__type === "outdoors" && "floor" in target) {
-    return target.floor;
-  }
-  const building = target;
-  if (building.excluded) {
-    return building.activeFloor;
-  }
-  switch (mode) {
-    case "lock-elevation":
-      return building.getFloorByElevation(elevation);
-    case "nearest-elevation":
-      return building.getNearestFloorByElevation(elevation);
-    default:
-      break;
-  }
-  return building.isIndoor ? building.activeFloor : building.defaultFloor;
-}
-__name(getFloorToShow, "getFloorToShow");
-function getFacadeState(facade, inFocus) {
-  return {
-    facade,
-    state: {
-      type: "facade",
-      visible: !inFocus,
-      opacity: inFocus ? 0 : 1
-    }
-  };
-}
-__name(getFacadeState, "getFacadeState");
-function getSingleBuildingState(floorStack, currentFloor, inFocus) {
-  return {
-    outdoorOpacity: 1,
-    floorStates: floorStack.floors.map((f) => {
-      const visible = f.id === currentFloor.id && inFocus;
-      return {
-        floor: f,
-        state: {
-          type: "floor",
-          visible,
-          geometry: {
-            visible
-          },
-          labels: {
-            enabled: visible
-          },
-          markers: {
-            enabled: visible
-          },
-          footprint: {
-            visible: false
-          },
-          occlusion: {
-            enabled: false
-          }
-        }
-      };
-    })
-  };
-}
-__name(getSingleBuildingState, "getSingleBuildingState");
-function getOutdoorOpacity(floorStackStates, mode) {
-  if (!mode.includes("lock-elevation")) {
-    return 1;
-  }
-  for (const state of floorStackStates) {
-    if (state.outdoorOpacity >= 0 && state.outdoorOpacity <= 1) {
-      return state.outdoorOpacity;
-    }
-  }
-  return 1;
-}
-__name(getOutdoorOpacity, "getOutdoorOpacity");
-function getSetFloorTargetFromZoomState(buildings, outdoors, zoomState) {
-  switch (zoomState) {
-    case "in-range":
-      return buildings[0]?.canSetFloor ? buildings[0] : void 0;
-    case "out-of-range":
-      return outdoors;
-    case "transition":
-    default:
-      return void 0;
-  }
-}
-__name(getSetFloorTargetFromZoomState, "getSetFloorTargetFromZoomState");
-function getBuildingStates(buildings, inViewSet, currentFloor, zoomState, mode, elevation, floorIdsInNavigation, floorStackIdsInNavigation, multiFloorView, getMultiFloorState3, dynamicBuildingInteriors) {
-  const buildingStates = /* @__PURE__ */ new Map();
-  for (const building of buildings) {
-    const inCameraView = inViewSet.has(building.id);
-    const showIndoor = shouldShowIndoor(
-      building,
-      currentFloor,
-      zoomState === "in-range",
-      inCameraView,
-      mode,
-      elevation,
-      floorStackIdsInNavigation.includes(building.id),
-      dynamicBuildingInteriors
-    );
-    const floorToShow = currentFloor.floorStack.id === building.id ? building.activeFloor : getFloorToShow(building, mode, elevation);
-    const floorStackState = multiFloorView.enabled ? getMultiFloorState3(
-      building.floors,
-      floorToShow || building.activeFloor,
-      multiFloorView?.floorGap,
-      floorIdsInNavigation,
-      building.floorsAltitudesMap
-    ) : getSingleBuildingState(building.floorStack, floorToShow || building.activeFloor, showIndoor);
-    const facadeState = getFacadeState(building.facade, showIndoor);
-    buildingStates.set(building.id, {
-      building,
-      showIndoor,
-      floorStackState,
-      facadeState,
-      inFocus: inCameraView,
-      floorToShow
-    });
-  }
-  return buildingStates;
-}
-__name(getBuildingStates, "getBuildingStates");
-function getBuildingAnimationType(building, showIndoor) {
-  if (building.excluded) {
-    return "none";
-  }
-  if (showIndoor) {
-    return "indoor";
-  }
-  return "outdoor";
-}
-__name(getBuildingAnimationType, "getBuildingAnimationType");
-function shouldShowIndoor(building, currentFloor, inRange, inFocus, mode, elevation, inNavigation, dynamicBuildingInteriors) {
-  if (building.id === currentFloor.floorStack.id) {
-    return true;
-  }
-  if (building.excluded) {
-    return false;
-  }
-  if (inNavigation === true) {
-    return true;
-  }
-  if (!dynamicBuildingInteriors) {
-    return currentFloor.floorStack.type !== "Outdoor";
-  }
-  if (!inRange) {
-    return false;
-  }
-  if (!inFocus) {
-    return false;
-  }
-  switch (mode) {
-    case "lock-elevation":
-      return building.getFloorByElevation(elevation) != null;
-    default:
-      break;
-  }
-  return true;
-}
-__name(shouldShowIndoor, "shouldShowIndoor");
-function shouldDeferSetFloor(trackedCameraElevation, currentCameraElevation, userInteracting) {
-  return trackedCameraElevation !== currentCameraElevation && !userInteracting;
-}
-__name(shouldDeferSetFloor, "shouldDeferSetFloor");
-
-// src/types.ts
-var DYNAMIC_FOCUS_MODES = ["default-floor", "lock-elevation", "nearest-elevation"];
-
-// src/validation.ts
-import { Floor as Floor2, FloorStack as FloorStack2 } from "@mappedin/mappedin-js";
-
-// ../packages/common/Mappedin.Logger.ts
-var MI_ERROR_LABEL = "[MappedinJS]";
-function createLogger(name = "", { prefix = MI_ERROR_LABEL } = {}) {
-  const label = `${prefix}${name ? `-${name}` : ""}`;
-  const rnDebug = /* @__PURE__ */ __name((type, args) => {
-    if (typeof window !== "undefined" && window.rnDebug) {
-      const processed = args.map((arg) => {
-        if (arg instanceof Error && arg.stack) {
-          return `${arg.message}
-${arg.stack}`;
-        }
-        return arg;
-      });
-      window.rnDebug(`${name} ${type}: ${processed.join(" ")}`);
-    }
-  }, "rnDebug");
-  return {
-    logState: define_process_default.env.NODE_ENV === "test" ? 3 /* SILENT */ : 0 /* LOG */,
-    log(...args) {
-      if (this.logState <= 0 /* LOG */) {
-        console.log(label, ...args);
-        rnDebug("log", args);
-      }
-    },
-    warn(...args) {
-      if (this.logState <= 1 /* WARN */) {
-        console.warn(label, ...args);
-        rnDebug("warn", args);
-      }
-    },
-    error(...args) {
-      if (this.logState <= 2 /* ERROR */) {
-        console.error(label, ...args);
-        rnDebug("error", args);
-      }
-    },
-    // It's a bit tricky to prepend [MappedinJs] to assert and time because of how the output is structured in the console, so it is left out for simplicity
-    assert(...args) {
-      console.assert(...args);
-    },
-    time(label2) {
-      console.time(label2);
-    },
-    timeEnd(label2) {
-      console.timeEnd(label2);
-    },
-    setLevel(level) {
-      if (0 /* LOG */ <= level && level <= 3 /* SILENT */) {
-        this.logState = level;
-      }
-    }
-  };
-}
-__name(createLogger, "createLogger");
-var Logger = createLogger();
-var Mappedin_Logger_default = Logger;
-
-// ../packages/common/math-utils.ts
-function clampWithWarning(x, lower, upper, warning) {
-  if (x < lower || x > upper) {
-    Mappedin_Logger_default.warn(warning);
-  }
-  return Math.min(upper, Math.max(lower, x));
-}
-__name(clampWithWarning, "clampWithWarning");
-
-// src/validation.ts
-function validateFloorForStack(floor, floorStack) {
-  if (!Floor2.is(floor) || floor?.floorStack == null || !FloorStack2.is(floorStack)) {
-    return false;
-  }
-  if (floor.floorStack.id !== floorStack.id) {
-    Mappedin_Logger_default.warn(`Floor (${floor.id}) does not belong to floor stack (${floorStack.id}).`);
-    return false;
-  }
-  return true;
-}
-__name(validateFloorForStack, "validateFloorForStack");
-function validateZoomThreshold(value, min, max, name) {
-  return clampWithWarning(value, min, max, `${name} must be between ${min} and ${max}.`);
-}
-__name(validateZoomThreshold, "validateZoomThreshold");
-
-// src/logger.ts
-var Logger2 = createLogger("", { prefix: "[DynamicFocus]" });
-
-// src/outdoors.ts
-var Outdoors = class {
-  static {
-    __name(this, "Outdoors");
-  }
-  __type = "outdoors";
-  #floorStack;
-  #mapView;
-  constructor(floorStack, mapView) {
-    this.#floorStack = floorStack;
-    this.#mapView = mapView;
-  }
-  get id() {
-    return this.#floorStack.id;
-  }
-  get floorStack() {
-    return this.#floorStack;
-  }
-  get floor() {
-    return this.#floorStack.defaultFloor;
-  }
-  matchesFloorStack(floorStack) {
-    return floorStack === this.#floorStack || floorStack === this.#floorStack.id;
-  }
-  #setVisible(visible) {
-    for (const floor of this.#floorStack.floors) {
-      this.#mapView.updateState(floor, {
-        visible
-      });
-    }
-  }
-  show() {
-    this.#setVisible(true);
-  }
-  hide() {
-    this.#setVisible(false);
-  }
-  destroy() {
-    if (!this.matchesFloorStack(this.#mapView.currentFloorStack)) {
-      this.hide();
-    }
-  }
-};
-function getOutdoorFloorStack(floorStacks, buildingsSet) {
-  const outdoorFloorStack = floorStacks.find((floorStack) => floorStack.type?.toLowerCase() === "outdoor");
-  if (outdoorFloorStack) {
-    return outdoorFloorStack;
-  }
-  const likelyOutdoorFloorStack = floorStacks.find(
-    (floorStack) => floorStack.facade == null && !buildingsSet.has(floorStack.id)
-  );
-  if (likelyOutdoorFloorStack) {
-    return likelyOutdoorFloorStack;
-  }
-  Logger2.warn("No good candidate for the outdoor floor stack was found. Using the first floor stack.");
-  return floorStacks[0];
-}
-__name(getOutdoorFloorStack, "getOutdoorFloorStack");
-
-// src/constants.ts
-import { getMultiFloorState } from "@mappedin/mappedin-js";
-var DEFAULT_STATE = {
-  indoorZoomThreshold: 18,
-  outdoorZoomThreshold: 17,
-  setFloorOnFocus: true,
-  autoFocus: false,
-  indoorAnimationOptions: {
-    duration: 150
-  },
-  outdoorAnimationOptions: {
-    duration: 150
-  },
-  autoAdjustFacadeHeights: false,
-  mode: "default-floor",
-  preloadFloors: true,
-  customMultiFloorVisibilityState: getMultiFloorState,
-  dynamicBuildingInteriors: true
-};
-
-// src/dynamic-focus.ts
-var DynamicFocus = class {
-  static {
-    __name(this, "DynamicFocus");
-  }
-  #pubsub;
-  #mapView;
-  #mapData;
-  #state = DEFAULT_STATE;
-  /**
-   * The buildings that are currently in view, sorted by the order they are in the facades-in-view-change event.
-   * While these will be within the camera view, these may not be in focus or showIndoor depending on the mode.
-   */
-  #sortedBuildingsInView = [];
-  /**
-   * The buildings that are currently in view, as a set of building ids.
-   */
-  #buildingIdsInViewSet = /* @__PURE__ */ new Set();
-  #buildings = /* @__PURE__ */ new Map();
-  #outdoors;
-  #userInteracting = false;
-  #pendingFacadeUpdate = false;
-  #floorElevation = 0;
-  #cameraElevation = 0;
-  /**
-   * Tracks the current zoom state based on camera zoom level:
-   * - 'in-range': Camera is zoomed in enough to show indoor details (>= indoorZoomThreshold)
-   * - 'out-of-range': Camera is zoomed out to show outdoor context (<= outdoorZoomThreshold)
-   * - 'transition': Camera is between the two thresholds (no floor changes occur)
-   */
-  #zoomState = "transition";
-  #viewState = "outdoor";
-  /**
-   * The facades that are actually focused and shown (filtered by showIndoor logic)
-   */
-  #facadesInFocus = [];
-  #enabled = false;
-  /**
-   * @internal
-   * Used to await the current scene update before starting a new one, or when the scene is updated asynchronously by an event.
-   */
-  sceneUpdateQueue = Promise.resolve();
-  /**
-   * Creates a new instance of the Dynamic Focus controller.
-   *
-   * @param mapView - The {@link MapView} to attach Dynamic Focus to.
-   * @param options - Options for configuring Dynamic Focus.
-   *
-   * @example
-   * ```ts
-   * const mapView = show3dMap(...);
-   * const df = new DynamicFocus(mapView);
-   * df.enable({ autoFocus: true });
-   *
-   * // pause the listener
-   * df.updateState({ autoFocus: false });
-   *
-   * // manually trigger a focus
-   * df.focus();
-   * ```
-   */
-  constructor(mapView) {
-    this.#pubsub = new PubSub();
-    this.#mapView = mapView;
-    Logger2.setLevel(Mappedin_Logger_default.logState);
-    this.#mapData = this.#mapView.getMapData();
-    this.#floorElevation = this.#mapView.currentFloor.elevation;
-    this.#cameraElevation = this.#mapView.Camera.elevation;
-    for (const facade of this.#mapData.getByType("facade")) {
-      this.#buildings.set(facade.floorStack.id, new Building(facade.floorStack, this.#mapView));
-    }
-    this.#outdoors = new Outdoors(
-      getOutdoorFloorStack(this.#mapData.getByType("floor-stack"), this.#buildings),
-      this.#mapView
-    );
-    this.#mapView.on("floor-change-start", this.#handleFloorChangeStart);
-    this.#mapView.on("camera-change", this.#handleCameraChange);
-    this.#mapView.on("facades-in-view-change", this.#handleFacadesInViewChange);
-    this.#mapView.on("user-interaction-start", this.#handleUserInteractionStart);
-    this.#mapView.on("user-interaction-end", this.#handleUserInteractionEnd);
-  }
-  /**
-   * Enables Dynamic Focus with the given options.
-   * @param options - The options to enable Dynamic Focus with.
-   */
-  enable(options) {
-    if (this.#enabled) {
-      Logger2.warn("enable() called on an already enabled Dynamic Focus instance.");
-      return;
-    }
-    this.#enabled = true;
-    this.#mapView.manualFloorVisibility = true;
-    this.#outdoors.show();
-    this.updateState({ ...this.#state, ...options });
-    this.#handleCameraChange({
-      zoomLevel: this.#mapView.Camera.zoomLevel,
-      center: this.#mapView.Camera.center,
-      bearing: this.#mapView.Camera.bearing,
-      pitch: this.#mapView.Camera.pitch
-    });
-    this.#mapView.Camera.updateFacadesInView();
-  }
-  /**
-   * Disables Dynamic Focus and returns the MapView to it's previous state.
-   */
-  disable() {
-    if (!this.#enabled) {
-      Logger2.warn("disable() called on an already disabled Dynamic Focus instance.");
-      return;
-    }
-    this.#enabled = false;
-    this.#mapView.manualFloorVisibility = false;
-  }
-  /**
-   * Returns true if Dynamic Focus is enabled.
-   */
-  get isEnabled() {
-    return this.#enabled;
-  }
-  /**
-   * Returns true if the current view state is indoor.
-   */
-  get isIndoor() {
-    return this.#viewState === "indoor";
-  }
-  /**
-   * Returns true if the current view state is outdoor.
-   */
-  get isOutdoor() {
-    return this.#viewState === "outdoor";
-  }
-  /**
-   * Sets the view state to indoor, regardless of the current zoom level.
-   */
-  setIndoor() {
-    this.#viewState = "indoor";
-    this.#zoomState = "in-range";
-    this.#handleViewStateChange();
-  }
-  /**
-   * Sets the view state to outdoor, regardless of the current zoom level.
-   */
-  setOutdoor() {
-    this.#viewState = "outdoor";
-    this.#zoomState = "out-of-range";
-    this.#handleViewStateChange();
-  }
-  #handleViewStateChange() {
-    if (this.#state.autoFocus) {
-      if (this.#userInteracting) {
-        this.focus();
-      } else {
-        this.#pendingFacadeUpdate = true;
-      }
-    }
-    this.#pubsub.publish("state-change");
-  }
-  #preloadFloors(mode) {
-    this.#mapView.preloadFloors(
-      this.#mapData.getByType("facade").map((facade) => getFloorToShow(this.#buildings.get(facade.floorStack.id), mode, this.#floorElevation)).filter((f) => f != null && Floor3.is(f))
-    );
-  }
-  /**
-   * Returns the facades that are currently in focus.
-   */
-  get focusedFacades() {
-    return [...this.#facadesInFocus];
-  }
-  /**
-   * Subscribe to a Dynamic Focus event.
-   */
-  on = /* @__PURE__ */ __name((eventName, fn) => {
-    this.#pubsub.on(eventName, fn);
-  }, "on");
-  /**
-   * Unsubscribe from a Dynamic Focus event.
-   */
-  off = /* @__PURE__ */ __name((eventName, fn) => {
-    this.#pubsub.off(eventName, fn);
-  }, "off");
-  /**
-   * Returns the current state of the Dynamic Focus controller.
-   */
-  getState() {
-    return { ...this.#state };
-  }
-  /**
-   * Updates the state of the Dynamic Focus controller.
-   * @param state - The state to update.
-   */
-  updateState(state) {
-    let shouldReapplyBuildingStates = false;
-    if (state.indoorZoomThreshold != null) {
-      state.indoorZoomThreshold = validateZoomThreshold(
-        state.indoorZoomThreshold,
-        state?.outdoorZoomThreshold ?? this.#state.outdoorZoomThreshold,
-        this.#mapView.Camera.maxZoomLevel,
-        "indoorZoomThreshold"
-      );
-      shouldReapplyBuildingStates = true;
-    }
-    if (state.outdoorZoomThreshold != null) {
-      state.outdoorZoomThreshold = validateZoomThreshold(
-        state.outdoorZoomThreshold,
-        this.#mapView.Camera.minZoomLevel,
-        state?.indoorZoomThreshold ?? this.#state.indoorZoomThreshold,
-        "outdoorZoomThreshold"
-      );
-      shouldReapplyBuildingStates = true;
-    }
-    if (state.mode != null) {
-      state.mode = DYNAMIC_FOCUS_MODES.includes(state.mode) ? state.mode : "default-floor";
-    }
-    if (state.autoAdjustFacadeHeights != null) {
-      this.#state.autoAdjustFacadeHeights = state.autoAdjustFacadeHeights;
-    }
-    if (state.dynamicBuildingInteriors != null && state.dynamicBuildingInteriors !== this.#state.dynamicBuildingInteriors) {
-      shouldReapplyBuildingStates = true;
-    }
-    this.#state = Object.assign(
-      {},
-      this.#state,
-      Object.fromEntries(Object.entries(state).filter(([, value]) => value != null))
-    );
-    if (state.mode != null && state.preloadFloors) {
-      this.#preloadFloors(state.mode);
-    }
-    if (shouldReapplyBuildingStates) {
-      this.#applyBuildingStates();
-    }
-  }
-  /**
-   * Destroys the Dynamic Focus instance and unsubscribes all MapView event listeners.
-   */
-  destroy() {
-    this.disable();
-    this.#mapView.off("facades-in-view-change", this.#handleFacadesInViewChange);
-    this.#mapView.off("floor-change-start", this.#handleFloorChangeStart);
-    this.#mapView.off("camera-change", this.#handleCameraChange);
-    this.#mapView.off("user-interaction-start", this.#handleUserInteractionStart);
-    this.#mapView.off("user-interaction-end", this.#handleUserInteractionEnd);
-    this.#buildings.forEach((building) => building.destroy());
-    this.#outdoors.destroy();
-    this.#pubsub.destroy();
-  }
-  /**
-   * Perform a manual visual update of the focused facades, and optionally set the floor.
-   * @param setFloor - Whether to set the floor. This will default to the current state of setFloorOnFocus.
-   */
-  async focus(setFloor = this.#state.setFloorOnFocus) {
-    if (setFloor) {
-      if (shouldDeferSetFloor(this.#cameraElevation, this.#mapView.Camera.elevation, this.#userInteracting)) {
-        this.#cameraElevation = this.#mapView.Camera.elevation;
-        this.#pendingFacadeUpdate = true;
-      } else {
-        const target = getSetFloorTargetFromZoomState(this.#sortedBuildingsInView, this.#outdoors, this.#zoomState);
-        const floor = target ? getFloorToShow(target, this.#state.mode, this.#floorElevation) : void 0;
-        if (floor && floor.id !== this.#mapView.currentFloor.id) {
-          this.#mapView.setFloor(floor, { context: "dynamic-focus" });
-        }
-      }
-    }
-    await this.#applyBuildingStates();
-    this.#pubsub.publish("focus", { facades: this.focusedFacades });
-  }
-  /**
-   * Preloads the initial floors for each building to improve performance when rendering the building for the first time. See {@link DynamicFocusState.preloadFloors}.
-   */
-  preloadFloors() {
-    this.#preloadFloors(this.#state.mode);
-  }
-  /**
-   * Sets the default floor for a floor stack. This is the floor that will be shown when focusing on a facade if there is no currently active floor in the stack.
-   * See {@link resetDefaultFloorForStack} to reset the default floor.
-   * @param floorStack - The floor stack to set the default floor for.
-   * @param floor - The floor to set as the default floor.
-   */
-  setDefaultFloorForStack(floorStack, floor) {
-    if (!validateFloorForStack(floor, floorStack)) {
-      return;
-    }
-    const building = this.#buildings.get(floorStack.id);
-    if (building) {
-      building.defaultFloor = floor;
-    }
-  }
-  /**
-   * Resets the default floor for a floor stack to it's initial value.
-   * @param floorStack - The floor stack to reset the default floor for.
-   */
-  resetDefaultFloorForStack(floorStack) {
-    const building = this.#buildings.get(floorStack.id);
-    if (building) {
-      building.defaultFloor = floorStack.defaultFloor;
-    }
-  }
-  /**
-   * Returns the current default floor for a floor stack.
-   * @param floorStack - The floor stack to get the default floor for.
-   * @returns The current default floor for the floor stack.
-   */
-  getDefaultFloorForStack(floorStack) {
-    return this.#buildings.get(floorStack.id)?.defaultFloor || floorStack.defaultFloor || floorStack.floors[0];
-  }
-  /**
-   * Sets the current floor for a floor stack. If the floor stack is currently focused, this floor will become visible.
-   * @param floorStack - The floor stack to set the current floor for.
-   */
-  setCurrentFloorForStack(floorStack, floor) {
-    if (!validateFloorForStack(floor, floorStack)) {
-      return;
-    }
-    const building = this.#buildings.get(floorStack.id);
-    if (building) {
-      building.activeFloor = floor;
-      this.#applyBuildingStates();
-    }
-  }
-  /**
-   * Excludes a floor stack from visibility changes.
-   * @param excluded - The floor stack or stacks to exclude.
-   */
-  exclude(excluded) {
-    const excludedFloorStacks = Array.isArray(excluded) ? excluded : [excluded];
-    for (const floorStack of excludedFloorStacks) {
-      const building = this.#buildings.get(floorStack.id);
-      if (building) {
-        building.excluded = true;
-      }
-    }
-  }
-  /**
-   * Includes a floor stack in visibility changes.
-   * @param included - The floor stack or stacks to include.
-   */
-  include(included) {
-    const includedFloorStacks = Array.isArray(included) ? included : [included];
-    for (const floorStack of includedFloorStacks) {
-      const building = this.#buildings.get(floorStack.id);
-      if (building) {
-        building.excluded = false;
-      }
-    }
-  }
-  /**
-   * Returns the current floor for a floor stack.
-   * @param floorStack - The floor stack to get the current floor for.
-   * @returns The current floor for the floor stack.
-   */
-  getCurrentFloorForStack(floorStack) {
-    return this.#buildings.get(floorStack.id)?.activeFloor || this.getDefaultFloorForStack(floorStack);
-  }
-  /**
-   * Handles management of focused facades but doesn't trigger view updates unless enabled.
-   * @see {@link focus} to manually trigger a view update.
-   */
-  #handleFacadesInViewChange = /* @__PURE__ */ __name((event) => {
-    if (!this.isEnabled) {
-      return;
-    }
-    const { facades } = event;
-    if (arraysEqual(facades, this.focusedFacades) && this.#viewState === "transition" && !this.#pendingFacadeUpdate) {
-      return;
-    }
-    this.#pendingFacadeUpdate = false;
-    this.#sortedBuildingsInView = [];
-    this.#buildingIdsInViewSet.clear();
-    if (facades.length > 0) {
-      for (const facade of facades) {
-        const building = this.#buildings.get(facade.floorStack.id);
-        if (building) {
-          this.#buildingIdsInViewSet.add(building.id);
-          this.#sortedBuildingsInView.push(building);
-        }
-      }
-    }
-    if (this.#state.autoFocus) {
-      this.focus();
-    }
-  }, "#handleFacadesInViewChange");
-  /**
-   * Handles floor and facade visibility when the floor changes.
-   */
-  #handleFloorChangeStart = /* @__PURE__ */ __name(async (event) => {
-    if (!this.isEnabled) {
-      return;
-    }
-    const { floor: newFloor } = event;
-    const building = this.#buildings.get(newFloor.floorStack.id);
-    if (building) {
-      building.activeFloor = newFloor;
-    }
-    if (building?.excluded === false && !this.#outdoors.matchesFloorStack(newFloor.floorStack)) {
-      this.#floorElevation = newFloor.elevation;
-    }
-    if (this.#mapView.manualFloorVisibility === true) {
-      if (event.reason !== "dynamic-focus") {
-        await this.#applyBuildingStates(newFloor);
-        this.#pubsub.publish("focus", { facades: this.focusedFacades });
-      }
-      const altitude = building?.floorsAltitudesMap.get(newFloor.elevation)?.altitude ?? 0;
-      if (this.#mapView.options.multiFloorView != null && this.#mapView.options.multiFloorView?.enabled && this.#mapView.options.multiFloorView?.updateCameraElevationOnFloorChange && this.#mapView.Camera.elevation !== altitude) {
-        this.#mapView.Camera.animateElevation(altitude, {
-          duration: 750,
-          easing: "ease-in-out"
-        });
-      }
-    }
-  }, "#handleFloorChangeStart");
-  #handleUserInteractionStart = /* @__PURE__ */ __name(() => {
-    this.#userInteracting = true;
-  }, "#handleUserInteractionStart");
-  #handleUserInteractionEnd = /* @__PURE__ */ __name(() => {
-    this.#userInteracting = false;
-  }, "#handleUserInteractionEnd");
-  /**
-   * Handles camera moving in and out of zoom range and fires a focus event if the camera is in range.
-   */
-  #handleCameraChange = /* @__PURE__ */ __name((event) => {
-    if (!this.isEnabled) {
-      return;
-    }
-    const { zoomLevel } = event;
-    const newZoomState = getZoomState(zoomLevel, this.#state.indoorZoomThreshold, this.#state.outdoorZoomThreshold);
-    if (this.#zoomState !== newZoomState) {
-      this.#zoomState = newZoomState;
-      if (newZoomState === "in-range") {
-        this.setIndoor();
-      } else if (newZoomState === "out-of-range") {
-        this.setOutdoor();
-      }
-    }
-  }, "#handleCameraChange");
-  #updateFloorVisibility(floorStates, shouldShow, inFocus) {
-    floorStates.forEach((floorState) => {
-      if (floorState.floor) {
-        if (shouldShow) {
-          const state = inFocus !== void 0 ? {
-            ...floorState.state,
-            labels: {
-              ...floorState.state.labels,
-              enabled: floorState.state.labels.enabled && inFocus
-            },
-            markers: {
-              ...floorState.state.markers,
-              enabled: floorState.state.markers.enabled && inFocus
-            },
-            occlusion: {
-              ...floorState.state.occlusion,
-              // We don't want this floor to occlude if it's not in focus
-              // Allows us to show a label above this floor while it's not active
-              enabled: floorState.state.occlusion.enabled && inFocus
-            }
-          } : floorState.state;
-          this.#mapView.updateState(floorState.floor, state);
-        } else {
-          this.#mapView.updateState(floorState.floor, { visible: false });
-        }
-      }
-    });
-  }
-  async #animateIndoorSequence(building, floorStackState, facadeState, inFocus) {
-    this.#updateFloorVisibility(floorStackState.floorStates, true, inFocus);
-    return building.animateFacade(facadeState.state, this.#state.indoorAnimationOptions);
-  }
-  async #animateOutdoorSequence(building, floorStackState, facadeState, floorStackIdsInNavigation) {
-    const result = await building.animateFacade(facadeState.state, this.#state.outdoorAnimationOptions);
-    if (result.result === "completed") {
-      this.#updateFloorVisibility(
-        floorStackState.floorStates,
-        shouldShowIndoor(
-          building,
-          this.#mapView.currentFloor,
-          this.#zoomState === "in-range",
-          this.#buildingIdsInViewSet.has(building.id),
-          this.#state.mode,
-          this.#floorElevation,
-          floorStackIdsInNavigation.includes(building.floorStack.id),
-          this.#state.dynamicBuildingInteriors
-        )
-      );
-    }
-    return result;
-  }
-  #applyBuildingStates = /* @__PURE__ */ __name(async (newFloor) => {
-    if (this.#mapView.manualFloorVisibility !== true || !this.isEnabled) {
-      return;
-    }
-    const currentFloor = newFloor || this.#mapView.currentFloor;
-    const multiFloorView = this.#mapView.options.multiFloorView;
-    const floorIdsInNavigation = this.#mapView.Navigation?.floors?.map((f) => f.id) || [];
-    const floorStackIdsInNavigation = this.#mapView.Navigation?.floorStacks.map((fs) => fs.id) || [];
-    const updatePromise = new Promise(async (resolve) => {
-      await this.sceneUpdateQueue;
-      const buildingStates = getBuildingStates(
-        Array.from(this.#buildings.values()),
-        this.#buildingIdsInViewSet,
-        currentFloor,
-        this.#zoomState,
-        this.#state.mode,
-        this.#floorElevation,
-        floorIdsInNavigation,
-        floorStackIdsInNavigation,
-        multiFloorView,
-        this.#state.customMultiFloorVisibilityState ?? getMultiFloorState2,
-        this.#state.dynamicBuildingInteriors
-      );
-      const floorStackStates = [];
-      await Promise.all(
-        Array.from(buildingStates.values()).map(async (buildingState) => {
-          const { building, showIndoor, floorStackState, facadeState, inFocus } = buildingState;
-          floorStackStates.push(floorStackState);
-          const animation = getBuildingAnimationType(building, showIndoor);
-          if (animation === "indoor") {
-            return this.#animateIndoorSequence(building, floorStackState, facadeState, inFocus);
-          } else if (animation === "outdoor") {
-            return this.#animateOutdoorSequence(building, floorStackState, facadeState, floorStackIdsInNavigation);
-          }
-        })
-      );
-      this.#mapView.Outdoor.setOpacity(getOutdoorOpacity(floorStackStates, this.#state.mode));
-      this.#facadesInFocus = this.#sortedBuildingsInView.filter((building) => buildingStates.get(building.id)?.showIndoor === true).map((building) => building.facade);
-      this.#pubsub.publish("focus", { facades: this.#facadesInFocus });
-      resolve();
-    });
-    this.sceneUpdateQueue = updatePromise;
-    return updatePromise;
-  }, "#applyBuildingStates");
-};
-
-export {
-  __name,
-  DynamicFocus
-};
-//# sourceMappingURL=chunk-RSECYADN.js.map