Merge pull request 'feat: use react-yandex-maps for location input (#8)' (#50) from feature/order-form into main

Reviewed-on: #50

src/components/order-form/form/location/helper.ts

@@ -0,0 +1,15 @@
+import { Location, StringCoordinates, StringLocation } from "./types";
+
+export const splitLocation = (stringifiedLocation: StringLocation) => {
+  return stringifiedLocation.replace(' ', '~').split('~');
+};
+
+export const stringifyLocation = (location: Location): StringLocation => {
+  const { coordinates, address } = location;
+  const [latitude, longitude] = coordinates;
+  const coordinatesString = `${latitude},${longitude}` satisfies StringCoordinates;
+  return `${coordinatesString} ${address}`;
+};
+
+const locationRe = new RegExp(/^[-0-9]+.[0-9]+,[-0-9]+.[0-9]+ .*/);
+export const isValidLocation = (value: string): value is StringLocation => locationRe.test(value);

src/components/order-form/form/location/index.ts

@@ -0,0 +1,4 @@
+export type { StringLocation } from './types';
+export * from './location-input';
+export * from './map';
+export * from './ymaps';

src/components/order-form/form/location/location-input/helper.ts

@@ -0,0 +1,40 @@
+import { YMapsApi } from "@pbe/react-yandex-maps/typings/util/typing";
+
+import { Address, Location, StringLocation } from "../types";
+import { splitLocation, stringifyLocation } from "../helper";
+
+export const formatLocation = (location: Location | undefined): StringLocation | '' => {
+  if (!location) {
+    return '';
+  }
+  return stringifyLocation(location);
+};
+
+const coordinatesRe = new RegExp(/^[-0-9]+.[0-9]+,[-0-9]+.[0-9]+/);
+export const extractAddress = (value: string) => value.replace(coordinatesRe, '').trim();
+
+export const getLocationByAddress = async (ymaps: YMapsApi, address: Address): Promise<Location> => {
+  try {
+    const result = await ymaps.geocode(address);
+    const firstGeoObject = result.geoObjects.get(
+      0,
+    ) as unknown as ymaps.IGeoObject<ymaps.IBasePointGeometry>;
+    const [latitude, longitude] = firstGeoObject.geometry.getCoordinates();
+    return { coordinates: [latitude, longitude], address };    
+  } catch (error) {
+    console.error(error);    
+  }
+};
+
+export const isRealLocation = async (ymaps: YMapsApi, stringifiedLocation: StringLocation) => {
+  const [coordinates, address] = splitLocation(stringifiedLocation);
+  try {
+    const result = await ymaps.geocode(coordinates);
+    const firstGeoObject = result.geoObjects.get(0) as ymaps.GeocodeResult;
+    const addressByCoordinates = firstGeoObject.getAddressLine();
+  
+    return address === addressByCoordinates;
+  } catch (error) {
+    console.error(error);
+  }
+};

src/components/order-form/form/location/location-input/index.ts

@@ -0,0 +1 @@
+export { LocationInput } from './location-input';

src/components/order-form/form/location/location-input/location-input.tsx

@@ -0,0 +1,144 @@
+import React, { forwardRef, memo, useEffect, useState } from 'react';
+import {
+  Input,
+  Box,
+  InputProps,
+  PopoverAnchor,
+  Popover,
+  PopoverContent,
+  PopoverBody,
+  List,
+  ListItem,
+} from '@chakra-ui/react';
+import { withYMaps } from '@pbe/react-yandex-maps';
+import { useTranslation } from 'react-i18next';
+
+import { Suggestion } from '../types';
+import { isValidLocation } from '../helper';
+
+import {
+  formatLocation,
+  getLocationByAddress,
+  isRealLocation,
+  extractAddress,
+} from './helper';
+import { LocationInputProps } from './types';
+
+export const LocationInput = memo(
+  withYMaps(
+    forwardRef<HTMLInputElement, LocationInputProps>(function LocationInput(
+      { ymaps, value, onChange, ...props },
+      ref,
+    ) {
+      const [inputValue, setInputValue] = useState<string>('');
+
+      useEffect(() => {
+        setInputValue(value);
+      }, [value]);
+
+      const [suggestions, setSuggestions] = useState<Suggestion[]>([]);
+      const [isSuggestionsPanelOpen, setIsSuggestionsPanelOpen] =
+        useState<boolean>(false);
+
+      const onInputChange: InputProps['onChange'] = async (e) => {
+        const newInputValue = e.target.value;
+        setInputValue(newInputValue);
+
+        if (newInputValue.trim().length > 3) {
+          try {
+            const address = extractAddress(newInputValue);
+            const results = await ymaps.suggest(address);
+            setSuggestions(results);
+          } catch (error) {
+            console.error(error);
+          }
+        } else {
+          setSuggestions([]);
+        }
+
+        setIsSuggestionsPanelOpen(suggestions.length > 1);
+      };
+
+      const onFocus: InputProps['onFocus'] = () => {
+        setIsSuggestionsPanelOpen(suggestions.length > 1);
+      };
+
+      const onBlur: InputProps['onBlur'] = async (e) => {
+        const inputValue = e.target.value;
+        if (
+          isValidLocation(inputValue) &&
+          (await isRealLocation(ymaps, inputValue))
+        ) {
+          onChange(inputValue);
+        } else {
+          setInputValue(value);
+        }
+        setIsSuggestionsPanelOpen(false);
+      };
+
+      const handleSuggestionClick = async ({ value: address }: Suggestion) => {
+        try {
+          const location = await getLocationByAddress(ymaps, address);
+          const newValue = formatLocation(location);
+          setInputValue(newValue);
+          onChange(newValue);
+        } catch (error) {
+          console.error(error);          
+        }
+      };
+
+      const { t } = useTranslation('~', {
+        keyPrefix: 'dry-wash.order-create.form.washing-location-field',
+      });
+
+      return (
+        <Box width='100%'>
+          <Popover
+            isOpen={isSuggestionsPanelOpen}
+            autoFocus={false}
+            placement='bottom-start'
+          >
+            <PopoverAnchor>
+              <Input
+                {...props}
+                ref={ref}
+                onBlur={onBlur}
+                value={inputValue}
+                onChange={onInputChange}
+                onFocus={onFocus}
+                placeholder={t('placeholder')}
+              />
+            </PopoverAnchor>
+            <PopoverContent width='100%' maxWidth='100%'>
+              <PopoverBody border='1px' borderColor='gray.300' p={0}>
+                <List>
+                  {suggestions.map((suggestion, index) => (
+                    <ListItem
+                      key={index}
+                      p={2}
+                      cursor='pointer'
+                      _hover={{
+                        bgColor: 'primary.50',
+                      }}
+                      _active={{
+                        bgColor: 'primary.100',
+                      }}
+                      onClick={() => handleSuggestionClick(suggestion)}
+                    >
+                      {suggestion.displayName}
+                    </ListItem>
+                  ))}
+                </List>
+              </PopoverBody>
+            </PopoverContent>
+          </Popover>
+        </Box>
+      );
+    }),
+    true,
+    ['suggest', 'geocode'],
+  ),
+);
+
+// todo: i18n
+// todo: replace console.error with toast

src/components/order-form/form/location/location-input/types.ts

@@ -0,0 +1,8 @@
+import { YMapsApi } from "@pbe/react-yandex-maps/typings/util/typing";
+import { InputProps } from "@chakra-ui/react";
+
+export type LocationInputProps = InputProps & {
+  ymaps?: YMapsApi;
+  value?: string;
+  onChange?: (value: string) => void;
+};

src/components/order-form/form/location/map/helper.ts

@@ -0,0 +1,10 @@
+import { splitLocation } from "../helper";
+import { Coordinate, Location, StringLocation } from "../types";
+
+export const KAZAN_CITY_CENTER: Coordinate[] = [55.797557, 49.107295];
+
+export const parseLocation = (stringifiedLocation: StringLocation): Location => {
+  const [coordinatesStr, address] = splitLocation(stringifiedLocation);
+  const [latitude, longitude] = coordinatesStr.split(',').map(Number);
+  return { coordinates: [latitude, longitude], address };
+};

src/components/order-form/form/location/map/index.ts

@@ -0,0 +1 @@
+export { MapComponent } from './map';

src/components/order-form/form/location/map/map.tsx

@@ -0,0 +1,70 @@
+import React, { FC, memo, useEffect, useState } from 'react';
+import {
+  Map,
+  Placemark,
+  GeolocationControl,
+  ZoomControl,
+  withYMaps,
+} from '@pbe/react-yandex-maps';
+import { YMapsApi } from '@pbe/react-yandex-maps/typings/util/typing';
+
+import { Coordinate, StringLocation } from '../types';
+import { isValidLocation, stringifyLocation } from '../helper';
+
+import { KAZAN_CITY_CENTER, parseLocation } from './helper';
+
+export const MapComponent: FC<{
+  ymaps?: YMapsApi;
+  selectedLocation: StringLocation | null;
+  onMapClick: (props: StringLocation) => void;
+}> = memo(
+  withYMaps(
+    ({ ymaps, selectedLocation, onMapClick }) => {
+      const [mapCenter, setMapCenter] =
+        useState<Coordinate[]>(KAZAN_CITY_CENTER);
+
+      useEffect(() => {
+        if (isValidLocation(selectedLocation)) {
+          const location = parseLocation(selectedLocation);
+          const { coordinates } = location;
+          setMapCenter(coordinates);
+        }
+      }, [selectedLocation]);
+
+      return (
+        <Map
+          state={{
+            center: mapCenter,
+            zoom:
+              isValidLocation(selectedLocation) &&
+              parseLocation(selectedLocation)?.coordinates
+                ? 17
+                : 10,
+          }}
+          width='100%'
+          onClick={async (e: ymaps.MapEvent) => {
+            try {
+              const coordinates = e.get('coords');
+              const address = await ymaps.geocode(coordinates).then((res) => {
+                const firstGeoObject = res.geoObjects.get(
+                  0,
+                ) as ymaps.GeocodeResult;
+                return firstGeoObject.getAddressLine();
+              });
+              onMapClick(stringifyLocation({ coordinates, address }));
+              setMapCenter(coordinates);
+            } catch (error) {
+              console.error(error);
+            }
+          }}
+        >
+          <GeolocationControl options={{ float: 'left' }} />
+          <ZoomControl />
+          {selectedLocation && <Placemark geometry={mapCenter} />}
+        </Map>
+      );
+    },
+    true,
+    ['geocode'],
+  ),
+);

src/components/order-form/form/location/types.ts

@@ -0,0 +1,17 @@
+export type Address = string;
+
+export type Suggestion = {
+  value: Address;
+  displayName: string;
+};
+
+export type Coordinate = number;
+
+export type Location = {
+  address: Address;
+  coordinates: [Coordinate, Coordinate];
+};
+
+export type StringCoordinates = `${Coordinate},${Coordinate}`;
+
+export type StringLocation = `${StringCoordinates} ${Address}`;

src/components/order-form/form/location/ymaps/index.ts

@@ -0,0 +1 @@
+export { YMapsProvider } from './ymaps-provider';

src/components/order-form/form/location/ymaps/ymaps-provider.tsx

@@ -0,0 +1,16 @@
+import { YMaps } from '@pbe/react-yandex-maps';
+import React, { PropsWithChildren } from 'react';
+
+export const YMapsProvider = ({ children }: PropsWithChildren) => {
+  return (
+    <YMaps
+      query={{
+        lang: 'ru_RU',
+        apikey: '19cbc387-db9a-4807-a620-5205215db40f',
+        suggest_apikey: '3576e65e-5e75-4ea2-b21c-7f9db112682e',
+      }}
+    >
+      {children}
+    </YMaps>
+  );
+};

src/components/order-form/form/order-form.tsx

@@ -1,14 +1,7 @@
 import React, { FC } from 'react';
 import { useForm } from 'react-hook-form';
 import { useTranslation } from 'react-i18next';
-import {
-  Box,
-  Flex,
-  FormControl,
-  FormLabel,
-  Input,
-  VStack,
-} from '@chakra-ui/react';
+import { Box, Flex, FormControl, FormLabel, VStack } from '@chakra-ui/react';
 
 import { CarBodySelect } from './car-body';
 import { CarColorInput } from './car-color';
@@ -19,6 +12,7 @@ import { PhoneInput } from './phone';
 import { SubmitButton } from './submit';
 import { defaultValues, onSubmit, useGetValidationRules } from './helper';
 import { DateTimeInput } from './date-time';
+import { LocationInput, MapComponent, StringLocation, YMapsProvider } from './location';
 
 export const OrderForm: FC = () => {
   const {
@@ -26,6 +20,7 @@ export const OrderForm: FC = () => {
     control,
     formState: { errors, isSubmitting },
     watch,
+    setValue,
   } = useForm<OrderFormValues>({ defaultValues, shouldFocusError: true });
 
   const { t } = useTranslation('~', {
@@ -34,9 +29,10 @@ export const OrderForm: FC = () => {
 
   const RULES = useGetValidationRules();
 
-  const [availableDatetimeBegin, availableDatetimeEnd] = watch([
+  const [availableDatetimeBegin, availableDatetimeEnd, carLocation] = watch([
     'availableDatetimeBegin',
     'availableDatetimeEnd',
+    'carLocation',
   ]);
 
   return (
@@ -81,15 +77,6 @@ export const OrderForm: FC = () => {
           errors={errors}
           Input={CarBodySelect}
         />
-        <FormInputField
-          control={control}
-          name='carLocation'
-          label={t('washing-location-field.label')}
-          isRequired
-          errors={errors}
-          Input={Input}
-          help={t('washing-location-field.help')}
-        />
         <FormControl isRequired>
           <FormLabel>{t('washing-datetime-field.label')}</FormLabel>
           <Flex flexWrap='wrap' gap={4}>
@@ -119,6 +106,23 @@ export const OrderForm: FC = () => {
             </Box>
           </Flex>
         </FormControl>
+        <YMapsProvider>
+          <FormInputField
+            control={control}
+            name='carLocation'
+            label={t('washing-location-field.label')}
+            help={t('washing-location-field.help')}
+            isRequired
+            errors={errors}
+            Input={LocationInput}
+          />
+          <MapComponent
+            selectedLocation={carLocation as StringLocation}
+            onMapClick={(location) => {
+              setValue('carLocation', location);
+            }}
+          />
+        </YMapsProvider>
         <SubmitButton isLoading={isSubmitting} mt={4} />
       </VStack>
     </Box>
@@ -126,5 +130,4 @@ export const OrderForm: FC = () => {
 };
 
 // todo: remove layout shift, when a validation message is displayed
-// todo: select location using an interactive map
-// todo: fix time range available values
+// todo: fix time range available values