-
Notifications
You must be signed in to change notification settings - Fork 634
/
autocomplete.ts
199 lines (189 loc) · 8.02 KB
/
autocomplete.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
/**
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import {
AddressType,
LatLng,
PredictionSubstring,
PredictionTerm,
RequestParams,
ResponseData,
StructuredFormatting,
} from "../common";
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
import { latLngToString, serializer } from "../serialize";
import { defaultAxiosInstance } from "../client";
export enum PlaceAutocompleteType {
/**
* instructs the Place Autocomplete service to return only geocoding results, rather than business results.
* Generally, you use this request to disambiguate results where the location specified may be indeterminate.
*/
geocode = "geocode",
/**
* instructs the Place Autocomplete service to return only geocoding results with a precise address.
* Generally, you use this request when you know the user will be looking for a fully specified address.
*/
address = "address",
/** instructs the Place Autocomplete service to return only business results. */
establishment = "establishment",
/**
* the `(regions)` type collection instructs the Places service to return any result matching the following types:
* - `locality`
* - `sublocality`
* - `postal_code`
* - `country`
* - `administrative_area_level_1`
* - `administrative_area_level_2`
*/
regions = "(regions)",
/** the (cities) type collection instructs the Places service to return results that match `locality` or `administrative_area_level_3`. */
cities = "(cities)",
}
export interface PlaceAutocompleteRequest extends Partial<AxiosRequestConfig> {
params: {
/**
* The text string on which to search. The Place Autocomplete service will return candidate matches
* based on this string and order results based on their perceived relevance.
*/
input: string;
/**
* A random string which identifies an autocomplete
* [session](https://developers.google.com/places/web-service/autocomplete#session_tokens) for billing purposes.
* If this parameter is omitted from an autocomplete request, the request is billed independently
*/
sessiontoken?: string;
/**
* The position, in the input term, of the last character that the service uses to match predictions.
* For example, if the input is 'Google' and the `offset` is 3, the service will match on 'Goo'.
* The string determined by the `offset` is matched against the first word in the input term only.
* For example, if the input term is 'Google abc' and the offset is 3, the service will attempt to match against 'Goo abc'.
* If no `offset` is supplied, the service will use the whole term.
* The `offset` should generally be set to the position of the text caret.
*/
offset?: number;
/**
* The origin point from which to calculate straight-line distance to the destination (returned as distance_meters).
* If this value is omitted, straight-line distance will not be returned.
*/
origin?: LatLng;
/** The point around which you wish to retrieve place information. */
location?: LatLng;
/**
* The distance (in meters) within which to return place results. Note that setting a radius biases results to the indicated area,
* but may not fully restrict results to the specified area.
*/
radius?: number;
/**
* The language code, indicating in which language the results should be returned, if possible.
* Searches are also biased to the selected language; results in the selected language may be given a higher ranking.
* See the list of supported languages and their codes.
* Note that we often update supported languages so this list may not be exhaustive.
* If language is not supplied, the Place Autocomplete service will attempt to use the native language
* of the domain from which the request is sent.
*/
language?: string;
/** The types of place results to return. */
types?: PlaceAutocompleteType;
/**
* A grouping of places to which you would like to restrict your results.
* Currently, you can use `components` to filter by up to 5 countries.
* Countries must be passed as a two character, ISO 3166-1 Alpha-2 compatible country code.
* For example: `components=country:fr` would restrict your results to places within France.
* Multiple countries must be passed as multiple `country:XX` filters, with the pipe character (`|`) as a separator.
* For example: `components=country:us|country:pr|country:vi|country:gu|country:mp` would restrict your results
* to places within the United States and its unincorporated organized territories.
*/
components?: string[];
/**
* Returns only those places that are strictly within the region defined by `location` and `radius`.
* This is a restriction, rather than a bias, meaning that results outside this region
* will not be returned even if they match the user input.
*/
strictbounds?: boolean;
} & RequestParams;
}
export interface PlaceAutocompleteResult {
/**
* contains the human-readable name for the returned result.
* For `establishment` results, this is usually the business name.
*/
description: string;
/**
* contains an integer indicating the straight-line distance between the predicted place, and the specified origin point, in meters.
* This field is only returned when the origin point is specified in the request.
* This field is not returned in predictions of type route.
*/
distance_meters?: number;
/**
* is a textual identifier that uniquely identifies a place.
* To retrieve information about the place, pass this identifier in the `placeId` field of a Places API request.
*/
place_id: string;
/**
* contains an array of terms identifying each section of the returned description
* (a section of the description is generally terminated with a comma).
*/
terms: PredictionTerm[];
/**
* contains an array of types that apply to this place.
* For example: `[ "political", "locality" ]` or `[ "establishment", "geocode" ]`.
*/
types: AddressType[];
/**
* contains an array with `offset` value and `length`. These describe the location of
* the entered term in the prediction result text, so that the term can be highlighted if desired.
*/
matched_substrings: PredictionSubstring[];
/** contains details on the prediction. */
structured_formatting: StructuredFormatting;
}
export interface PlaceAutocompleteResponseData extends ResponseData {
/**
* contains an array of places, with information about the place.
* See [Place Autocomplete Results](https://developers.google.com/places/web-service/autocomplete#place_autocomplete_results)
* for information about these results. The Places API returns up to 5 results.
*/
predictions: PlaceAutocompleteResult[];
}
export interface PlaceAutocompleteResponse extends AxiosResponse {
data: PlaceAutocompleteResponseData;
}
export const defaultUrl =
"https://maps.googleapis.com/maps/api/place/autocomplete/json";
export const defaultParamsSerializer = serializer(
{
location: latLngToString,
origin: latLngToString,
},
defaultUrl
);
export function placeAutocomplete(
{
params,
method = "get",
url = defaultUrl,
paramsSerializer = defaultParamsSerializer,
...config
}: PlaceAutocompleteRequest,
axiosInstance: AxiosInstance = defaultAxiosInstance
): Promise<PlaceAutocompleteResponse> {
return axiosInstance({
params,
method,
url,
paramsSerializer,
...config,
}) as Promise<PlaceAutocompleteResponse>;
}