@aws-amplify/geo 2.3.6-api-v6-models.b3abc9b.0 → 3.0.0

package/lib/util.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
+exports.getGeoUserAgentString = exports.getGeoUserAgent = exports.mapSearchOptions = exports.validateGeofencesInput = exports.validatePolygon = exports.validateLinearRing = exports.validateGeofenceId = exports.validateCoordinates = void 0;
+const tslib_1 = require("tslib");
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var boolean_clockwise_1 = tslib_1.__importDefault(require("@turf/boolean-clockwise"));
+const boolean_clockwise_1 = tslib_1.__importDefault(require("@turf/boolean-clockwise"));
+const utils_1 = require("@aws-amplify/core/internals/utils");
 function validateCoordinates(lng, lat) {
     if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
-        throw new Error("Invalid coordinates: [" + lng + "," + lat + "]");
+        throw new Error(`Invalid coordinates: [${lng},${lat}]`);
     }
     if (lat < -90 || 90 < lat) {
         throw new Error('Latitude must be between -90 and 90 degrees inclusive.');
@@ -17,107 +19,107 @@ function validateCoordinates(lng, lat) {
 }
 exports.validateCoordinates = validateCoordinates;
 function validateGeofenceId(geofenceId) {
-    var geofenceIdRegex = /^[-._\p{L}\p{N}]+$/iu;
+    const geofenceIdRegex = /^[-._\p{L}\p{N}]+$/iu;
     // Check if geofenceId is valid
     if (!geofenceIdRegex.test(geofenceId)) {
-        throw new Error("Invalid geofenceId: '" + geofenceId + "' - IDs can only contain alphanumeric characters, hyphens, underscores and periods.");
+        throw new Error(`Invalid geofenceId: '${geofenceId}' - IDs can only contain alphanumeric characters, hyphens, underscores and periods.`);
     }
 }
 exports.validateGeofenceId = validateGeofenceId;
 function validateLinearRing(linearRing, geofenceId) {
-    var errorPrefix = geofenceId ? geofenceId + ": " : '';
+    const errorPrefix = geofenceId ? `${geofenceId}: ` : '';
     // Validate LinearRing size, must be at least 4 points
     if (linearRing.length < 4) {
-        throw new Error(errorPrefix + "LinearRing must contain 4 or more coordinates.");
+        throw new Error(`${errorPrefix}LinearRing must contain 4 or more coordinates.`);
     }
     // Validate all coordinates are valid, error with which ones are bad
-    var badCoordinates = [];
-    linearRing.forEach(function (coordinates) {
+    const badCoordinates = [];
+    linearRing.forEach(coordinates => {
         try {
             validateCoordinates(coordinates[0], coordinates[1]);
         }
         catch (error) {
-            badCoordinates.push({ coordinates: coordinates, error: error.message });
+            badCoordinates.push({ coordinates, error: error.message });
         }
     });
     if (badCoordinates.length > 0) {
-        throw new Error(errorPrefix + "One or more of the coordinates in the Polygon LinearRing are not valid: " + JSON.stringify(badCoordinates));
+        throw new Error(`${errorPrefix}One or more of the coordinates in the Polygon LinearRing are not valid: ${JSON.stringify(badCoordinates)}`);
     }
     // Validate first and last coordinates are the same
-    var _a = tslib_1.__read(linearRing[0], 2), lngA = _a[0], latA = _a[1];
-    var _b = tslib_1.__read(linearRing[linearRing.length - 1], 2), lngB = _b[0], latB = _b[1];
+    const [lngA, latA] = linearRing[0];
+    const [lngB, latB] = linearRing[linearRing.length - 1];
     if (lngA !== lngB || latA !== latB) {
-        throw new Error(errorPrefix + "LinearRing's first and last coordinates are not the same");
+        throw new Error(`${errorPrefix}LinearRing's first and last coordinates are not the same`);
     }
-    if (boolean_clockwise_1.default(linearRing)) {
-        throw new Error(errorPrefix + "LinearRing coordinates must be wound counterclockwise");
+    if ((0, boolean_clockwise_1.default)(linearRing)) {
+        throw new Error(`${errorPrefix}LinearRing coordinates must be wound counterclockwise`);
     }
 }
 exports.validateLinearRing = validateLinearRing;
 function validatePolygon(polygon, geofenceId) {
-    var errorPrefix = geofenceId ? geofenceId + ": " : '';
+    const errorPrefix = geofenceId ? `${geofenceId}: ` : '';
     if (!Array.isArray(polygon)) {
-        throw new Error(errorPrefix + "Polygon is of incorrect structure. It should be an array of LinearRings");
+        throw new Error(`${errorPrefix}Polygon is of incorrect structure. It should be an array of LinearRings`);
     }
     if (polygon.length < 1) {
-        throw new Error(errorPrefix + "Polygon must have a single LinearRing array.");
+        throw new Error(`${errorPrefix}Polygon must have a single LinearRing array.`);
     }
     if (polygon.length > 1) {
-        throw new Error(errorPrefix + "Polygon must have a single LinearRing array. Note: We do not currently support polygons with holes, multipolygons, polygons that are wound clockwise, or that cross the antimeridian.");
+        throw new Error(`${errorPrefix}Polygon must have a single LinearRing array. Note: We do not currently support polygons with holes, multipolygons, polygons that are wound clockwise, or that cross the antimeridian.`);
     }
-    var verticesCount = polygon.reduce(function (prev, linearRing) { return prev + linearRing.length; }, 0);
+    const verticesCount = polygon.reduce((prev, linearRing) => prev + linearRing.length, 0);
     if (verticesCount > 1000) {
-        throw new Error(errorPrefix + "Polygon has more than the maximum 1000 vertices.");
+        throw new Error(`${errorPrefix}Polygon has more than the maximum 1000 vertices.`);
     }
-    polygon.forEach(function (linearRing) {
+    polygon.forEach(linearRing => {
         validateLinearRing(linearRing, geofenceId);
     });
 }
 exports.validatePolygon = validatePolygon;
 function validateGeofencesInput(geofences) {
-    var geofenceIds = {};
-    geofences.forEach(function (geofence) {
+    const geofenceIds = {};
+    geofences.forEach((geofence) => {
         // verify all required properties are present
         // Validate geofenceId exists
         if (!geofence.geofenceId) {
-            throw new Error("Geofence '" + geofence + "' is missing geofenceId");
+            throw new Error(`Geofence '${geofence}' is missing geofenceId`);
         }
-        var geofenceId = geofence.geofenceId;
+        const { geofenceId } = geofence;
         validateGeofenceId(geofenceId);
         // Validate geofenceId is unique
         if (geofenceIds[geofenceId]) {
-            throw new Error("Duplicate geofenceId: " + geofenceId);
+            throw new Error(`Duplicate geofenceId: ${geofenceId}`);
         }
         else {
             geofenceIds[geofenceId] = true;
         }
         // Validate geometry exists
         if (!geofence.geometry) {
-            throw new Error("Geofence '" + geofenceId + "' is missing geometry");
+            throw new Error(`Geofence '${geofenceId}' is missing geometry`);
         }
-        var geometry = geofence.geometry;
+        const { geometry } = geofence;
         // Validate polygon exists
         if (!geometry.polygon) {
-            throw new Error("Geofence '" + geofenceId + "' is missing geometry.polygon");
+            throw new Error(`Geofence '${geofenceId}' is missing geometry.polygon`);
         }
-        var polygon = geometry.polygon;
+        const { polygon } = geometry;
         // Validate polygon length and structure
         try {
             validatePolygon(polygon, geofenceId);
         }
         catch (error) {
             if (error.message.includes('Polygon has more than the maximum 1000 vertices.')) {
-                throw new Error("Geofence '" + geofenceId + "' has more than the maximum of 1000 vertices");
+                throw new Error(`Geofence '${geofenceId}' has more than the maximum of 1000 vertices`);
             }
         }
         // Validate LinearRing length, structure, and coordinates
-        var _a = tslib_1.__read(polygon, 1), linearRing = _a[0];
+        const [linearRing] = polygon;
         validateLinearRing(linearRing, geofenceId);
     });
 }
 exports.validateGeofencesInput = validateGeofencesInput;
 function mapSearchOptions(options, locationServiceInput) {
-    var locationServiceModifiedInput = tslib_1.__assign({}, locationServiceInput);
+    const locationServiceModifiedInput = { ...locationServiceInput };
     locationServiceModifiedInput.FilterCountries = options.countries;
     locationServiceModifiedInput.MaxResults = options.maxResults;
     if (options.searchIndexName) {
@@ -135,4 +137,17 @@ function mapSearchOptions(options, locationServiceInput) {
     return locationServiceModifiedInput;
 }
 exports.mapSearchOptions = mapSearchOptions;
-//# sourceMappingURL=util.js.map
+function getGeoUserAgent(action) {
+    return (0, utils_1.getAmplifyUserAgentObject)({
+        category: utils_1.Category.Geo,
+        action,
+    });
+}
+exports.getGeoUserAgent = getGeoUserAgent;
+function getGeoUserAgentString(action) {
+    return (0, utils_1.getAmplifyUserAgent)({
+        category: utils_1.Category.Geo,
+        action,
+    });
+}
+exports.getGeoUserAgentString = getGeoUserAgentString;

package/lib-esm/Geo.d.ts

@@ -1,4 +1,4 @@
-import { Place, GeoConfig, Coordinates, SearchByTextOptions, SearchByCoordinatesOptions, GeoProvider, MapStyle, GeofenceId, GeofenceInput, GeofenceOptions, SaveGeofencesResults, Geofence, ListGeofenceOptions, ListGeofenceResults, DeleteGeofencesResults, searchByPlaceIdOptions } from './types';
+import { Place, Coordinates, SearchByTextOptions, SearchByCoordinatesOptions, GeoProvider, MapStyle, GeofenceId, GeofenceInput, GeofenceOptions, SaveGeofencesResults, Geofence, ListGeofenceOptions, ListGeofenceResults, DeleteGeofencesResults, searchByPlaceIdOptions } from './types';
 export declare class GeoClass {
     static MODULE: string;
     /**
@@ -16,7 +16,7 @@ export declare class GeoClass {
      * add plugin into Geo category
      * @param {Object} pluggable - an instance of the plugin
      */
-    addPluggable(pluggable: GeoProvider): object;
+    addPluggable(pluggable: GeoProvider): void;
     /**
      * Get the plugin object
      * @param providerName - the name of the plugin
@@ -27,12 +27,6 @@ export declare class GeoClass {
      * @param providerName - the name of the plugin
      */
     removePluggable(providerName: string): void;
-    /**
-     * Configure Geo
-     * @param {Object} config - Configuration object for Geo
-     * @return {Object} - Current configuration
-     */
-    configure(config?: any): GeoConfig;
     /**
      * Get the map resources that are currently available through the provider
      * @param {string} provider
@@ -65,7 +59,7 @@ export declare class GeoClass {
      * @param  {searchByPlaceIdOptions} options? - Optional parameters to the search
      * @returns {Promise<Place>} - Resolves to a place with the given placeId
      */
-    searchByPlaceId(placeId: string, options?: searchByPlaceIdOptions): Promise<Place>;
+    searchByPlaceId(placeId: string, options?: searchByPlaceIdOptions): Promise<Place | undefined>;
     /**
      * Reverse geocoding search via a coordinate point on the map
      * @param coordinates - Coordinates array for the search input