LocationSearchProviderMixin.ts

import { action, makeObservable, override } from "mobx";
import Ellipsoid from "terriajs-cesium/Source/Core/Ellipsoid";
import CesiumMath from "terriajs-cesium/Source/Core/Math";
import Rectangle from "terriajs-cesium/Source/Core/Rectangle";
import AbstractConstructor from "../../Core/AbstractConstructor";
import CommonStrata from "../../Models/Definition/CommonStrata";
import Model from "../../Models/Definition/Model";
import Terria from "../../Models/Terria";
import LocationSearchProviderTraits from "../../Traits/SearchProviders/LocationSearchProviderTraits";
import SearchProviderMixin from "./SearchProviderMixin";

type LocationSearchProviderModel = Model<LocationSearchProviderTraits>;

function LocationSearchProviderMixin<
  T extends AbstractConstructor<LocationSearchProviderModel>
>(Base: T) {
  abstract class LocationSearchProviderMixin extends SearchProviderMixin(Base) {
    constructor(...args: any[]) {
      super(...args);
      makeObservable(this);
    }

    get hasLocationSearchProviderMixin() {
      return true;
    }

    @action
    toggleOpen(stratumId: CommonStrata = CommonStrata.user) {
      this.setTrait(stratumId, "isOpen", !this.isOpen);
    }

    @action
    showWarning() {}

    async search(searchText: string, manuallyTriggered?: boolean) {
      if (!this.autocompleteEnabled && !manuallyTriggered) {
        this.searchResult.isSearching = false;
        this.searchResult.isWaitingToStartSearch = false;
        this.searchResult.message = {
          content: "translate#viewModels.enterToStartSearch"
        };

        return;
      }

      await super.search(searchText, manuallyTriggered);
    }

    @override
    get autocompleteEnabled() {
      return super.autocompleteEnabled ?? true;
    }
  }

  return LocationSearchProviderMixin;
}

interface MapCenter {
  longitude: number;
  latitude: number;
}

export function getMapCenter(terria: Terria): MapCenter {
  const view = terria.currentViewer.getCurrentCameraView();
  if (view.position !== undefined) {
    const cameraPositionCartographic = Ellipsoid.WGS84.cartesianToCartographic(
      view.position
    );
    return {
      longitude: CesiumMath.toDegrees(cameraPositionCartographic.longitude),
      latitude: CesiumMath.toDegrees(cameraPositionCartographic.latitude)
    };
  } else {
    const center = Rectangle.center(view.rectangle);
    return {
      longitude: CesiumMath.toDegrees(center.longitude),
      latitude: CesiumMath.toDegrees(center.latitude)
    };
  }
}

namespace LocationSearchProviderMixin {
  export interface Instance
    extends InstanceType<ReturnType<typeof LocationSearchProviderMixin>> {}

  export function isMixedInto(model: any): model is Instance {
    return model && model.hasLocationSearchProviderMixin;
  }
}

export default LocationSearchProviderMixin;