wip

Author: mdastous-bentley

packages/itwin/geo-tools/src/AddressProvider.ts

@@ -5,7 +5,7 @@ import type { Cartographic } from "@itwin/core-common";
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 import type { Range2d } from "@itwin/core-geometry";
-import type { MapCartoRectangle } from "@itwin/core-frontend";
+import type { MapCartoRectangle, Viewport } from "@itwin/core-frontend";
 export interface AddressData {
   formattedAddress: string;
 }
@@ -17,11 +17,19 @@ export interface AddressRequest {
     body?: string;
 }
 
+export interface AddressProviderViewContext {
+  viewport?: Viewport;
+}
+
+
 export interface GeoCoder {
   getLocation(data: AddressData): Promise<Cartographic>;
 }
 
 export interface AddressProvider {
   getSuggestions(query: string, viewRect: MapCartoRectangle): Promise<AddressData[]>;
   supportsAddressLocation(): this is GeoCoder;
+
+  /** Indicates whether the address provider should be disabled in the current view context*/
+  isDisabled(context: AddressProviderViewContext): boolean;
 }

packages/itwin/geo-tools/src/BingAddressProvider.ts

@@ -2,7 +2,7 @@
 import { IModelApp } from "@itwin/core-frontend";
 
 import type { MapCartoRectangle } from "@itwin/core-frontend";
-import type { GeoCoder, AddressProvider, AddressRequest, AddressData } from "./AddressProvider";
+import type { GeoCoder, AddressProvider, AddressRequest, AddressData, AddressProviderViewContext } from "./AddressProvider";
 
 export class BingAddressProvider implements AddressProvider {
   private _radius = 5000;
@@ -15,6 +15,10 @@ export class BingAddressProvider implements AddressProvider {
       return false;
     }
 
+  public isDisabled(_context: AddressProviderViewContext) {
+    return false;
+  };
+
   constructor(radius?: number, maxResults?: number, entityTypes?: string[]) {
     if (maxResults !== undefined) {
       this._maxResults = maxResults;

packages/itwin/geo-tools/src/GeoToolsItemDef.tsx

@@ -6,6 +6,7 @@
 import React from "react";
 import { ToolbarItemUtilities } from "@itwin/appui-react";
 import { SvgGeosearch } from "@itwin/itwinui-icons-react";
+import { BingAddressProvider } from "./BingAddressProvider";
 import { GeoAddressSearch } from "./components/GeoAddressSearch";
 import { GeoTools } from "./GeoTools";
 
@@ -25,7 +26,7 @@ export class GeoToolsItemDef {
       id: "geo-tools:geoAddressSearch",
       icon: <SvgGeosearch />,
       label: GeoTools.translate("geoAddressSearch.label"),
-      panelContent: <GeoAddressSearch provider={opts?.addressProvider}/>,
+      panelContent: <GeoAddressSearch provider={opts?.addressProvider?? new BingAddressProvider()}/>,
     });
   }
 }

packages/itwin/geo-tools/src/GoogleAddressProvider.ts

@@ -3,11 +3,11 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 
-import { Cartographic } from "@itwin/core-common";
+import { BaseMapLayerSettings, Cartographic } from "@itwin/core-common";
 import { IModelApp } from "@itwin/core-frontend";
 
-import type { MapCartoRectangle } from "@itwin/core-frontend";
-import type { AddressProvider, AddressRequest, AddressData, GeoCoder } from "./AddressProvider";
+import type { MapCartoRectangle, Viewport } from "@itwin/core-frontend";
+import type { AddressProvider, AddressRequest, AddressData, GeoCoder, AddressProviderViewContext } from "./AddressProvider";
 
 /**
  * Information requiered to retreive location from Google Places API.
@@ -25,6 +25,7 @@ export class GoogleAddressProvider implements AddressProvider {
   private _apiKey: string;
   public readonly hasAddressIds = true;
 
+
   constructor(locationBiasRadius?: number) {
     if (locationBiasRadius !== undefined) {
       this._radius = locationBiasRadius;
@@ -40,6 +41,18 @@ export class GoogleAddressProvider implements AddressProvider {
     return true;
   }
 
+  private isGoogleBaseMap (vp?: Viewport): boolean  {
+        return (
+            vp?.viewFlags.backgroundMap === true
+            && vp?.displayStyle.backgroundMapBase instanceof BaseMapLayerSettings
+            && vp.displayStyle.backgroundMapBase.formatId === "GoogleMaps"
+        );
+  };
+
+  public isDisabled(context: AddressProviderViewContext) {
+    return !this.isGoogleBaseMap(context.viewport);
+    };
+
   protected async getAuthRequestHeader(): Promise<Record<string, string>> {
     return { "X-Goog-Api-Key": this._apiKey};
   }

packages/itwin/geo-tools/src/components/GeoAddressSearch.tsx

@@ -6,12 +6,9 @@
 import "./GeoAddressSearch.scss";
 import * as React from "react";
 import { useActiveViewport } from "@itwin/appui-react";
-import { BaseMapLayerSettings } from "@itwin/core-common";
 import { SvgCloseSmall, SvgSearch } from "@itwin/itwinui-icons-react";
 import { ComboBox, IconButton } from "@itwin/itwinui-react";
-import { BingAddressProvider } from "../BingAddressProvider";
 import { GeoTools } from "../GeoTools";
-import { GoogleAddressProvider } from "../GoogleAddressProvider";
 import { IModelGeoView } from "../IModelGeoView";
 
 import type { Viewport } from "@itwin/core-frontend";
@@ -22,52 +19,37 @@ import type { AddressData, AddressProvider } from "../AddressProvider";
  */
 export interface GeoAddressSearchProps {
   /** Address provider object */
-  provider?: AddressProvider;
+  provider: AddressProvider;
+
   /** Indicates whether to set focus to the input element (default to true)*/
   setFocus?: boolean;
 }
-
-const isGoogleBaseMap = (vp?: Viewport): boolean => {
-      return (
-          vp?.viewFlags.backgroundMap === true
-          && vp?.displayStyle.backgroundMapBase instanceof BaseMapLayerSettings
-          && vp.displayStyle.backgroundMapBase.formatId === "GoogleMaps"
-      );
-};
-const isValidBaseMap = (provider: AddressProvider, vp?: Viewport) => {
-  const isGoogleAddressProvider = provider instanceof GoogleAddressProvider;
-  return !isGoogleAddressProvider || (isGoogleAddressProvider && isGoogleBaseMap(vp));
-}
-
 /**
- * <GeoAddressSearch> react component
  */
 export function GeoAddressSearch(props: GeoAddressSearchProps) {
+  const {provider} = props;
+
   const [inputValue, setInputValue] = React.useState("");
   const [options, setOptions] = React.useState<SelectOption<string>[]>([]);
   const [addressCache, setAddressCache] = React.useState<AddressData[]>([]);
   const activeViewport = useActiveViewport(); // Hook to ensure the component re-renders when the active viewport changes
-  const [disabled, setDisabled] = React.useState<boolean>(() => isGoogleBaseMap(activeViewport));
-
-  // `React.useMemo' is used avoid creating new object on each render cycle
-  // Default is Bing provider, but we might want to default to Google in the future
-  const addressProvider = React.useMemo(() => props.provider ?? new BingAddressProvider(), [props.provider]);
+  const [disabled, setDisabled] = React.useState<boolean>(() => provider.isDisabled({ viewport: activeViewport }) );
 
   React.useEffect(() => {
-    setDisabled(!isValidBaseMap(addressProvider, activeViewport));
+
     return activeViewport?.onDisplayStyleChanged.addListener(
-      (vp)=>{setDisabled(!isValidBaseMap(addressProvider, vp));}
+      (vp)=>{setDisabled(provider?.isDisabled({ viewport: vp }) );}
     );
   }, [activeViewport]);
 
   const onAddressSelected = async (selected: string) => {
     setInputValue(selected);
     let locatedByPosition = false
-    if (addressProvider.supportsAddressLocation()) {
+    if (provider.supportsAddressLocation()) {
       const address = addressCache.find((addr) => addr.formattedAddress === selected);
         if (address !== undefined) {
           try {
-            const location = await addressProvider.getLocation(address);
+            const location = await provider.getLocation(address);
             if (location) {
               locatedByPosition = await IModelGeoView.locatePosition(location);
             }
@@ -83,7 +65,7 @@ export function GeoAddressSearch(props: GeoAddressSearchProps) {
   const getAddressesFunc = async (value: string): Promise<AddressData[]> => {
     const viewBBox = IModelGeoView.getFrustumLonLatBBox();
     if (viewBBox && value) {
-      const addr = await addressProvider.getSuggestions(value, viewBBox);
+      const addr = await provider.getSuggestions(value, viewBBox);
       setAddressCache(addr);
       return addr;
     }

packages/itwin/geo-tools/src/test/GeoAddressSearch.test.tsx

@@ -5,7 +5,7 @@
 
 import { expect } from "chai";
 import { mount } from "enzyme";
-import * as React from "react";
+import React from "react";
 import * as sinon from "sinon";
 import { stubObject } from "ts-sinon";
 import { SpecialKey } from "@itwin/appui-abstract";
@@ -60,7 +60,7 @@ describe("GeoAddressSearch", () => {
   });
 
   it("renders", () => {
-    const wrapper = mount(<GeoAddressSearch />);
+    const wrapper = mount(<GeoAddressSearch provider={new BingAddressProvider()}/>);
 
     expect(wrapper.find("input[type='text']").length).to.eq(1);
     wrapper.unmount();