@azure-rest/maps-render 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,224 @@
+# Azure MapsRender REST client library for JavaScript
+
+Azure Maps Render Client
+
+\*\*If you are not familiar with our REST client, please spend 5 minutes to take a look at our [REST client docs](https://github.com/Azure/azure-sdk-for-js/blob/main/documentation/rest-clients.md) to use this library, the REST client provides a light-weighted & developer friendly way to call azure rest api
+
+Key links:
+
+- [Source code][source_code]
+- [Package (NPM)][npm_package]
+- [API reference documentation][api_ref]
+- [Product Information][product_info]
+
+## Getting started
+
+### Currently supported environments
+
+- [LTS versions of Node.js][nodejs_release]
+- Latest versions of Safari, Chrome, Edge and Firefox.
+
+### Prerequisites
+
+- You must have an [Azure subscription][az_subscription] to use this package.
+- An [Azure Maps account][az_maps_account_management]. You can create the resource via the [Azure Portal][azure_portal], the [Azure PowerShell][azure_powershell], or the [Azure CLI][azure_cli].
+
+If you use Azure CLI, replace `<resource-group-name>` and `<map-account-name>` of your choice, and select a proper [pricing tier][az_map_pricing] based on your needs via the `<sku-name>` parameter. Please refer to [Azure Maps Reference for Azure CLI][az_map_az_cli] for more details.
+
+```bash
+az maps account create --resource-group <resource-group-name> --name <map-account-name> --sku <sku-name>
+```
+
+### Install the `@azure-rest/maps-render` package
+
+Install the Azure Maps Render REST client library for JavaScript with `npm`:
+
+```bash
+npm install @azure-rest/maps-render
+```
+
+### Create and authenticate a `MapsRenderClient`
+
+You'll need a `credential` instance for authentication when creating the `MapsRenderClient` instance used to access the Azure Maps render APIs. You can use either an Azure Active Directory (Azure AD) credential or an Azure subscription key to authenticate. For more information on authentication, see [Authentication with Azure Maps][az_map_auth].
+
+#### Using an Azure AD credential
+
+To use an [Azure Active Directory (AAD) token credential](https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity/samples/AzureIdentityExamples.md#authenticating-with-a-pre-fetched-access-token),
+provide an instance of the desired credential type obtained from the
+[@azure/identity](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/identity/identity#credentials) library.
+
+To authenticate with AAD, you must first `npm` install [`@azure/identity`](https://www.npmjs.com/package/@azure/identity)
+
+After setup, you can choose which type of [credential](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/identity/identity#credentials) from `@azure/identity` to use.
+As an example, [DefaultAzureCredential](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/identity/identity#defaultazurecredential)
+can be used to authenticate the client.
+
+You'll need to register the new Azure AD application and grant access to Azure Maps by assigning the required role to your service principal. For more information, see [Host a daemon on non-Azure resources](https://learn.microsoft.com/azure/azure-maps/how-to-secure-daemon-app#host-a-daemon-on-non-azure-resources). Set the values of the client ID, tenant ID, and client secret of the AAD application as environment variables:
+`AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`.
+
+You will also need to specify the Azure Maps resource you intend to use by specifying the `clientId` in the client options.
+The Azure Maps resource client id can be found in the Authentication sections in the Azure Maps resource. Please refer to the [documentation](https://docs.microsoft.com/azure/azure-maps/how-to-manage-authentication#view-authentication-details) on how to find it.
+
+```javascript
+const MapsRender = require("@azure-rest/maps-render").default;
+const { DefaultAzureCredential } = require("@azure/identity");
+
+const credential = new DefaultAzureCredential();
+const client = MapsRender(credential, "<maps-account-client-id>");
+```
+
+#### Using a Subscription Key Credential
+
+You can authenticate with your Azure Maps Subscription Key. Please install the `@azure/core-auth` package:
+
+```bash
+npm install @azure/core-auth
+```
+
+```javascript
+const MapsRender = require("@azure-rest/maps-render").default;
+const AzureKeyCredential = require("@azure/core-auth");
+
+const credential = new AzureKeyCredential("<subscription-key>");
+const client = MapsRender(credential);
+```
+
+## Key concepts
+
+### MapsRenderClient
+
+`MapsRenderClient` is the primary interface for developers using the Azure Maps Render client library. Explore the methods on this client object to understand the different features of the Azure Maps Render service that you can access.
+
+## Examples
+
+The following sections provide several code snippets covering some of the most common Azure Maps Render tasks, including:
+
+- [Request map tiles in vector or raster formats](#request-map-tiles-in-vector-or-raster-formats)
+- [Request map copyright attribution information](#request-map-copyright-attribution-information)
+- [Request metadata for a tileset](#request-metadata-for-a-tileset)
+
+### Request map tiles in vector or raster formats
+
+You can request map tiles in vector or raster formats. These tiles are typically to be integrated into a map control or SDK.
+Some example tiles that can be requested are Azure Maps road tiles, real-time Weather Radar tiles or the map tiles created using [Azure Maps Creator](https://docs.microsoft.com/shows/internet-of-things-show/introducing-azure-maps-creator).
+
+```javascript
+const { createWriteStream } = require("fs");
+const { positionToTileXY } = require("@azure-rest/maps-render");
+
+const zoom = 6;
+// Use the helper function `positionToTileXY` to get the tile index from the coordinate.
+const { x, y } = positionToTileXY([47.61559, -122.33817], 6, "256");
+const response = await client
+  .path("/map/tile")
+  .get({
+    queryParameters: {
+      tilesetId: "microsoft.base.road",
+      zoom,
+      x,
+      y,
+    },
+  })
+  .asNodeStream();
+
+// Handle the error.
+if (!response.body) {
+  throw Error("No response body");
+}
+response.body.pipe(createWriteStream("tile.png"));
+```
+
+### Request map copyright attribution information
+
+You can request map copyright attribution information for a section of a tileset.
+A tileset is a collection of raster or vector data broken up into a uniform grid of square tiles at preset zoom levels. Every tileset has a tilesetId to use when making requests. The supported tilesetIds are listed [here](https://docs.microsoft.com/rest/api/maps/render-v2/get-map-attribution?tabs=HTTP#tilesetid).
+
+```javascript
+const { isUnexpected } = require("@azure-rest/maps-render");
+
+const response = await client.path("/map/attribution").get({
+  queryParameters: {
+    tilesetId: "microsoft.base",
+    zoom: 6,
+    /** The order is [SouthwestCorner_Longitude, SouthwestCorner_Latitude, NortheastCorner_Longitude, NortheastCorner_Latitude] */
+    bounds: [-122.414162, 47.57949, -122.247157, 47.668372],
+  },
+});
+
+// Handle exception.
+if (isUnexpected(response)) {
+  throw response.body.error;
+}
+
+console.log("Copyright attribution for microsoft.base: ");
+baseResponse.body.copyrights.forEach((copyright) => console.log(copyright));
+```
+
+### Request metadata for a tileset
+
+You can request metadata for a tileset in TileJSON format using the following code snippet.
+
+```javascript
+const { isUnexpected } = require("@azure-rest/maps-render");
+
+const response = await client.path("/map/tileset").get({
+  queryParameters: {
+    tilesetId: "microsoft.base",
+  },
+});
+
+if (isUnexpected(response)) {
+  throw response.body.error;
+}
+
+console.log("The metadata of Microsoft Base tileset: ");
+const { maxzoom, minzoom, bounds = [] } = response.body;
+console.log(`The zoom range started from ${minzoom} to ${maxzoom}`);
+console.log(
+  `The left bound is ${bounds[0]}, bottom bound is ${bounds[1]}, right bound is ${bounds[2]}, and top bound is ${bounds[3]}`
+);
+```
+
+## Troubleshooting
+
+### Logging
+
+Enabling logging may help uncover useful information about failures. In order to see a log of HTTP requests and responses, set the `AZURE_LOG_LEVEL` environment variable to `info`. Alternatively, logging can be enabled at runtime by calling `setLogLevel` in the `@azure/logger`:
+
+```javascript
+const { setLogLevel } = require("@azure/logger");
+
+setLogLevel("info");
+```
+
+For more detailed instructions on how to enable logs, you can look at the [@azure/logger package docs](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/core/logger).
+
+## Next steps
+
+Please take a look at the [samples][samples] directory for detailed examples on how to use this library.
+
+## Contributing
+
+If you'd like to contribute to this library, please read the [contributing guide](https://github.com/Azure/azure-sdk-for-js/blob/master/CONTRIBUTING.md) to learn more about how to build and test the code.
+
+## Related projects
+
+- [Microsoft Azure SDK for JavaScript](https://github.com/Azure/azure-sdk-for-js)
+
+![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-js%2Fsdk%2Fmaps%2Fmaps-render-rest%2FREADME.png)
+
+<!-- [source_code]: https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/maps/maps-render-rest -->
+<!-- [npm_package]: https://www.npmjs.com/package/@azure-rest/maps-render -->
+<!-- [api_ref]: https://docs.microsoft.com/javascript/api/@azure-rest/maps-render?view=azure-node-preview -->
+<!-- [samples]: https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/maps/maps-render-rest/samples -->
+
+[product_info]: https://docs.microsoft.com/rest/api/maps/render-v2
+[nodejs_release]: https://nodejs.org/about/releases/
+[az_subscription]: https://azure.microsoft.com/free/
+[az_maps_account_management]: https://docs.microsoft.com/azure/azure-maps/how-to-manage-account-keys
+[azure_portal]: https://portal.azure.com
+[azure_powershell]: https://docs.microsoft.com/powershell/module/az.maps/new-azmapsaccount
+[azure_cli]: https://docs.microsoft.com/cli/azure
+[az_map_pricing]: https://docs.microsoft.com/azure/azure-maps/choose-pricing-tier
+[az_map_az_cli]: https://docs.microsoft.com/cli/azure/maps/account?view=azure-cli-latest#az_maps_account_create
+[az_map_auth]: https://learn.microsoft.com/azure/azure-maps/azure-maps-authentication

package/dist/index.js

@@ -0,0 +1,365 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var coreAuth = require('@azure/core-auth');
+var coreRestPipeline = require('@azure/core-rest-pipeline');
+var mapsCommon = require('@azure/maps-common');
+var coreClient = require('@azure-rest/core-client');
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Initialize a new instance of the class MapsRenderClient class.
+ * @param credentials type: KeyCredential
+ */
+function createClient(credentials, options = {}) {
+    var _a, _b;
+    const baseUrl = (_a = options.baseUrl) !== null && _a !== void 0 ? _a : `https://atlas.microsoft.com`;
+    options.apiVersion = (_b = options.apiVersion) !== null && _b !== void 0 ? _b : "2022-08-01";
+    options = Object.assign(Object.assign({}, options), { credentials: {
+            apiKeyHeaderName: "subscription-key"
+        } });
+    const userAgentInfo = `azsdk-js-maps-render-rest/1.0.0-beta.1`;
+    const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
+        ? `${options.userAgentOptions.userAgentPrefix} ${userAgentInfo}`
+        : `${userAgentInfo}`;
+    options = Object.assign(Object.assign({}, options), { userAgentOptions: {
+            userAgentPrefix
+        } });
+    const client = coreClient.getClient(baseUrl, credentials, options);
+    return client;
+}
+
+// Copyright (c) Microsoft Corporation.
+function MapsRender(credential, clientIdOrOptions = {}, maybeOptions = {}) {
+    const options = typeof clientIdOrOptions === "string" ? maybeOptions : clientIdOrOptions;
+    /**
+     * maps service requires a header "ms-x-client-id", which is different from the standard AAD.
+     * So we need to do our own implementation.
+     * This customized authentication is following by this guide: https://github.com/Azure/azure-sdk-for-js/blob/main/documentation/RLC-customization.md#custom-authentication
+     */
+    if (coreAuth.isTokenCredential(credential)) {
+        const clientId = typeof clientIdOrOptions === "string" ? clientIdOrOptions : "";
+        if (!clientId) {
+            throw Error("Client id is needed for TokenCredential");
+        }
+        const client = createClient(undefined, options);
+        client.pipeline.addPolicy(coreRestPipeline.bearerTokenAuthenticationPolicy({
+            credential,
+            scopes: `${options.baseUrl || "https://atlas.microsoft.com"}/.default`,
+        }));
+        client.pipeline.addPolicy(mapsCommon.createMapsClientIdPolicy(clientId));
+        return client;
+    }
+    return createClient(credential, options);
+}
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+const responseMap = {
+    "GET /map/tile": ["200"],
+    "GET /map/tileset": ["200"],
+    "GET /map/attribution": ["200"],
+    "GET /map/statetile": ["200"],
+    "GET /map/copyright/caption/{format}": ["200"],
+    "GET /map/static/{format}": ["200"],
+    "GET /map/copyright/bounding/{format}": ["200"],
+    "GET /map/copyright/tile/{format}": ["200"],
+    "GET /map/copyright/world/{format}": ["200"]
+};
+function isUnexpected(response) {
+    const lroOriginal = response.headers["x-ms-original-url"];
+    const url = new URL(lroOriginal !== null && lroOriginal !== void 0 ? lroOriginal : response.request.url);
+    const method = response.request.method;
+    let pathDetails = responseMap[`${method} ${url.pathname}`];
+    if (!pathDetails) {
+        pathDetails = geParametrizedPathSuccess(method, url.pathname);
+    }
+    return !pathDetails.includes(response.status);
+}
+function geParametrizedPathSuccess(method, path) {
+    var _a, _b;
+    const pathParts = path.split("/");
+    // Iterate the responseMap to find a match
+    for (const [key, value] of Object.entries(responseMap)) {
+        // Extracting the path from the map key which is in format
+        // GET /path/foo
+        if (!key.startsWith(method)) {
+            continue;
+        }
+        const candidatePath = getPathFromMapKey(key);
+        // Get each part of the url path
+        const candidateParts = candidatePath.split("/");
+        // If the candidate and actual paths don't match in size
+        // we move on to the next candidate path
+        if (candidateParts.length === pathParts.length &&
+            hasParametrizedPath(key)) {
+            // track if we have found a match to return the values found.
+            let found = true;
+            for (let i = 0; i < candidateParts.length; i++) {
+                if (((_a = candidateParts[i]) === null || _a === void 0 ? void 0 : _a.startsWith("{")) &&
+                    ((_b = candidateParts[i]) === null || _b === void 0 ? void 0 : _b.endsWith("}"))) {
+                    // If the current part of the candidate is a "template" part
+                    // it is a match with the actual path part on hand
+                    // skip as the parameterized part can match anything
+                    continue;
+                }
+                // If the candidate part is not a template and
+                // the parts don't match mark the candidate as not found
+                // to move on with the next candidate path.
+                if (candidateParts[i] !== pathParts[i]) {
+                    found = false;
+                    break;
+                }
+            }
+            // We finished evaluating the current candidate parts
+            // if all parts matched we return the success values form
+            // the path mapping.
+            if (found) {
+                return value;
+            }
+        }
+    }
+    // No match was found, return an empty array.
+    return [];
+}
+function hasParametrizedPath(path) {
+    return path.includes("/{");
+}
+function getPathFromMapKey(mapKey) {
+    const pathStart = mapKey.indexOf("/");
+    return mapKey.slice(pathStart);
+}
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+function clip(n, minValue, maxValue) {
+    return Math.min(Math.max(n, minValue), maxValue);
+}
+const MIN_LATITUDE = -85.05112878;
+const MAX_LATITUDE = 85.05112878;
+const MIN_LONGITUDE = -180;
+const MAX_LONGITUDE = 180;
+/**
+ * Calculates the XY tile coordinates that a coordinate falls into for a specific zoom level.
+ * Reference: https://learn.microsoft.com/en-us/azure/azure-maps/zoom-levels-and-tile-grid?tabs=typescript#tile-math-source-code
+ *
+ * @example
+ * ```ts
+ * const zoom = 6;
+ * const { x, y } = positionToTileXY([47.61559, -122.33817], 6, "256");
+ * const response = await client
+ *   .path("/map/tile")
+ *   .get({
+ *     queryParameters: { tilesetId: "microsoft.base.road", zoom, x, y },
+ *   })
+ * ```
+ *
+ * @param position - Position coordinate in the format [latitude, longitude].
+ * @param zoom - Zoom level.
+ * @param tileSize - The size of the tiles in the tile pyramid.
+ * @returns Tile XY coordinates.
+ */
+function positionToTileXY(position, zoom, tileSize) {
+    const latitude = clip(position[0], MIN_LATITUDE, MAX_LATITUDE);
+    const longitude = clip(position[1], MIN_LONGITUDE, MAX_LONGITUDE);
+    const x = (longitude + 180) / 360;
+    const sinLatitude = Math.sin((latitude * Math.PI) / 180);
+    const y = 0.5 - Math.log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI);
+    const tileSizeInNum = parseInt(tileSize);
+    // tileSize needed in calculations as in rare cases the multiplying/rounding/dividing can make the difference of a pixel which can result in a completely different tile.
+    const mapSize = Math.ceil(tileSizeInNum * Math.pow(2, zoom));
+    return {
+        x: Math.floor(clip(x * mapSize + 0.5, 0, mapSize - 1) / tileSizeInNum),
+        y: Math.floor(clip(y * mapSize + 0.5, 0, mapSize - 1) / tileSizeInNum),
+    };
+}
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * @internal
+ * Workaround to create a path query string for [ collectionFormat: multi ](https://swagger.io/docs/specification/2-0/describing-parameters/#:~:text=csv%20(-,default,-)).
+ * This should be removed once the core-client support collectionFormat: multi.
+ */
+function createMultiCollection(key, values) {
+    return values.slice(1).reduce((acc, value) => {
+        return `${acc}&${key}=${value}`;
+    }, values[0] || "");
+}
+
+// Copyright (c) Microsoft Corporation.
+const optionKeyMap$1 = {
+    opacity: "al",
+    labelAnchor: "la",
+    labelColor: "lc",
+    labelSizeInPixels: "ls",
+    pinAnchor: "an",
+    rotationInDegree: "ro",
+    scale: "sc",
+    pinColor: "co",
+};
+function isOptionKeyMap(key) {
+    return key in optionKeyMap$1;
+}
+/**
+ * Create a pin query string for _get map static image_
+ *
+ * @example
+ * ```ts
+ *
+ * const pins = {
+ *  pins: [
+ *    { coordinate: [52.577, 13.35], label: "Label start" },
+ *    { coordinate: [52.6, 13.2988], label: "Label end" },
+ *  ],
+ *  pinImage: "<image source url || default || none>"
+ *  options: {
+ *    scale: 0.9,
+ *    pinColor: "FF0000",
+ *    labelColor: "0000FF",
+ *    labelSizeInPixels: 18,
+ *  }
+ * );
+ * const res = await client
+ *  .path("/map/static/{format}", "png")
+ *  .get({
+ *    queryParameters: {
+ *      bbox: [13.228, 52.4559, 13.5794, 52.62],
+ *      zoom: 10,
+ *      pins: pins,
+ *    },
+ *    skipUrlEncoding: true,
+ *  })
+ * ```
+ *
+ * @param pins - An array of {@link Pin} that specify the positions and label text of each pin.
+ * @param pinImage - Specify the image source for custom pin. Set this to "none" if you don't want to show a pin image.
+ * @param options - The style options of the pins. See {@link PinOptions}
+ * @returns - The composed query string.
+ */
+function createPinsQuery(pinSets) {
+    const pinsQueries = pinSets.map(({ pins, pinImage = "default", options = {} }) => {
+        // compose the pins' position query string
+        const pinsQueryStr = pins
+            .map(({ coordinate: [lat, lon], label }) => `${label ? `'${label}'` : ""}${lon} ${lat}`)
+            .join("|");
+        // compose the options query string
+        const optionsQueryStr = Object.entries(options).reduce((queryStr, [key, val]) => {
+            if (!isOptionKeyMap(key))
+                throw Error(`Unexpected option: ${key}`);
+            if (Array.isArray(val))
+                return (queryStr += `|${optionKeyMap$1[key]}${val[0]} ${val[1]}`);
+            return (queryStr += `|${optionKeyMap$1[key]}${val}`);
+        }, "");
+        if (pinImage === "none" || pinImage === "default") {
+            return `${pinImage}${optionsQueryStr}||${pinsQueryStr}`;
+        }
+        return `custom${optionsQueryStr}||${pinsQueryStr}||${pinImage}`;
+    });
+    return createMultiCollection("pins", pinsQueries);
+}
+
+// Copyright (c) Microsoft Corporation.
+function isCircularPath(path) {
+    return "center" in path;
+}
+const optionKeyMap = {
+    lineColor: "lc",
+    lineOpacity: "la",
+    fillColor: "fc",
+    fillOpacity: "fa",
+    lineWidthInPixels: "lw",
+    radius: "ra",
+};
+function isOptionKey(key) {
+    return key in optionKeyMap;
+}
+function comosePathVal(coordinates, options) {
+    // compose the coordinates query string
+    const coordinatesQueryStr = coordinates.map(([lat, lon]) => `${lon} ${lat}`).join("|");
+    // compose the options query string
+    const optionsQueryStr = Object.entries(options).reduce((queryStr, [key, val]) => {
+        if (!isOptionKey(key))
+            throw Error(`Unknown key ${key}`);
+        queryStr += `${queryStr ? "|" : ""}${optionKeyMap[key]}${val}`;
+        return queryStr;
+    }, "");
+    return optionsQueryStr + "||" + coordinatesQueryStr;
+}
+/**
+ * Create a path query string for _get map static image_ request.
+ *
+ * @example
+ * ```ts
+ * const circularPath = {
+ *   center: [52.4559, 13.228],
+ *   radiusInMeters: 10000,
+ *   options: {
+ *     lineColor: "000000",
+ *     lineOpacity: 0.9,
+ *     lineWidthInPixels: 2,
+ *   },
+ * };
+ *
+ * const linearPath = {
+ *   coordinates: [
+ *     [52.577, 13.35],
+ *     [52.6, 13.2988],
+ *     [52.32, 13.2988],
+ *   ],
+ *   options: {
+ *     lineColor: "000000",
+ *     lineOpacity: 0.9,
+ *     lineWidthInPixels: 2,
+ *   },
+ * };
+ *
+ * const polygonPath = {
+ *  coordinates: [
+ *    [52.577, 13.35],
+ *    [52.6, 13.2988],
+ *    [52.32, 13.2988],
+ *    [52.577, 13.35],
+ *  ],
+ *  options: {
+ *    lineColor: "000000",
+ *    lineOpacity: 0.9,
+ *    lineWidthInPixels: 2,
+ *    fillColor: "FFFFFF",
+ *    fillOpacity: 0.8,
+ *  },
+ * };
+ *
+ * const path = createPathQuery([circularPath, linearPath, polygonPath]);
+ * // Send the request
+ * const response = await client.path("/map/static/{format}", "png").get({
+ *  queryParameters: {
+ *    bbox: [13.228,52.4559,13.5794,52.629],
+ *    path: path
+ *  }
+ * });
+ * ```
+ *
+ * @param paths - A collection of {@link PolygonalPath} and {@link CircularPath} that you want to draw on the image.
+ * @param options - The options for the style of the path. See the possible options in {@link PolygonalPathOptions} and {@link CircularPathOptions}.
+ */
+function createPathQuery(paths) {
+    const pathQueries = paths.map((path) => {
+        if (isCircularPath(path)) {
+            const { center, radiusInMeters, options } = path;
+            return comosePathVal([center], Object.assign(Object.assign({}, options), { radius: radiusInMeters }));
+        }
+        return comosePathVal(path.coordinates, path.options || {});
+    });
+    return createMultiCollection("path", pathQueries);
+}
+
+// Copyright (c) Microsoft Corporation.
+
+exports.createPathQuery = createPathQuery;
+exports.createPinsQuery = createPinsQuery;
+exports["default"] = MapsRender;
+exports.isUnexpected = isUnexpected;
+exports.positionToTileXY = positionToTileXY;
+//# sourceMappingURL=index.js.map