From 2fa0ab9cf03dc2fd0321dd53ec04c1ae00804474 Mon Sep 17 00:00:00 2001
From: Malte Modrow <modrow@ubilabs.net>
Date: Mon, 9 Dec 2024 15:01:50 +0100
Subject: [PATCH 1/5] feat(static): first version of static maps component with
 SSR support

---
 package.json                                  |   8 +-
 src/components/static-map.tsx                 |  21 +++
 src/index.ts                                  |   1 +
 .../assemble-map-type-styles.ts               |  48 ++++++
 .../assemble-marker-params.ts                 |  77 ++++++++++
 .../assemble-path-params.ts                   |  79 ++++++++++
 .../create-static-maps-url/helpers.ts         |  26 ++++
 src/libraries/create-static-maps-url/index.ts | 140 ++++++++++++++++++
 src/libraries/create-static-maps-url/types.ts |  37 +++++
 src/server/index.ts                           |   3 +
 10 files changed, 439 insertions(+), 1 deletion(-)
 create mode 100644 src/components/static-map.tsx
 create mode 100644 src/libraries/create-static-maps-url/assemble-map-type-styles.ts
 create mode 100644 src/libraries/create-static-maps-url/assemble-marker-params.ts
 create mode 100644 src/libraries/create-static-maps-url/assemble-path-params.ts
 create mode 100644 src/libraries/create-static-maps-url/helpers.ts
 create mode 100644 src/libraries/create-static-maps-url/index.ts
 create mode 100644 src/libraries/create-static-maps-url/types.ts
 create mode 100644 src/server/index.ts

diff --git a/package.json b/package.json
index 9698d5f..2ab1cde 100644
--- a/package.json
+++ b/package.json
@@ -11,6 +11,11 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.modern.mjs"
     },
+    "./server": {
+      "require": "./dist/server/index.umd.js",
+      "types": "./dist/server/index.d.ts",
+      "default": "./dist/server/index.modern.mjs"
+    },
     "./examples.css": "./dist/examples.css"
   },
   "types": "dist/index.d.ts",
@@ -25,10 +30,11 @@
   "license": "MIT",
   "scripts": {
     "clean": "rm -rf ./dist && mkdir ./dist",
-    "build": "npm-run-all clean -p build:*",
+    "build": "npm-run-all clean -p build:**",
     "start": "run-p start:*",
     "build:examples": "cp ./examples/examples.css dist",
     "build:microbundle": "microbundle -o dist/index.js -f modern,umd --globals react=React,react-dom=ReactDOM --jsx React.createElement --jsxFragment React.Fragment --no-compress --tsconfig tsconfig.build.json",
+    "build:microbundle:server": "microbundle -o dist/server/index.js -f modern,umd --globals react=React,react-dom=ReactDOM --jsx React.createElement --jsxFragment React.Fragment --no-compress --tsconfig tsconfig.build.json ./src/server/index.ts",
     "start:microbundle": "microbundle watch -o dist/index.js -f modern,umd --globals react=React,react-dom=ReactDOM --jsx React.createElement --jsxFragment React.Fragment --no-compress --tsconfig tsconfig.build.json",
     "test:linter": "eslint 'src/**/*.{ts,tsx}'",
     "test:tsc": "tsc --project tsconfig.test.json --noEmit",
diff --git a/src/components/static-map.tsx b/src/components/static-map.tsx
new file mode 100644
index 0000000..7813068
--- /dev/null
+++ b/src/components/static-map.tsx
@@ -0,0 +1,21 @@
+import React from 'react';
+
+export {createStaticMapsUrl} from '../libraries/create-static-maps-url';
+export * from '../libraries/create-static-maps-url/types';
+
+/**
+ * Props for the StaticMap component
+ */
+export type StaticMapProps = {
+  url: string;
+};
+
+export const StaticMap = async (props: StaticMapProps) => {
+  const {url} = props;
+
+  if (!url) {
+    return null;
+  }
+
+  return <img src={url} width="100%" />;
+};
diff --git a/src/index.ts b/src/index.ts
index 08514a5..2463f30 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -4,6 +4,7 @@ export * from './components/advanced-marker';
 export * from './components/api-provider';
 export * from './components/info-window';
 export * from './components/map';
+export * from './components/static-map';
 export * from './components/map-control';
 export * from './components/marker';
 export * from './components/pin';
diff --git a/src/libraries/create-static-maps-url/assemble-map-type-styles.ts b/src/libraries/create-static-maps-url/assemble-map-type-styles.ts
new file mode 100644
index 0000000..83d016e
--- /dev/null
+++ b/src/libraries/create-static-maps-url/assemble-map-type-styles.ts
@@ -0,0 +1,48 @@
+/**
+ * Converts an array of Google Maps style objects into an array of style strings
+ * compatible with the Google Static Maps API.
+ *
+ * @param styles - An array of Google Maps MapTypeStyle objects that define the styling rules
+ * @returns An array of formatted style strings ready to be used with the Static Maps API
+ *
+ * @example
+ * const styles = [{
+ *   featureType: "road",
+ *   elementType: "geometry",
+ *   stylers: [{color: "#ff0000"}, {weight: 1}]
+ * }];
+ *
+ * const styleStrings = assembleMapTypeStyles(styles);
+ * // Returns: ["|feature:road|element:geometry|color:0xff0000|weight:1"]
+ *
+ * Each style string follows the format:
+ * "|feature:{featureType}|element:{elementType}|{stylerName}:{stylerValue}"
+ *
+ * Note: Color values with hexadecimal notation (#) are automatically converted
+ * to the required 0x format for the Static Maps API.
+ */
+export function assembleMapTypeStyles(
+  styles: Array<google.maps.MapTypeStyle>
+): string[] {
+  return styles.map((mapTypeStyle: google.maps.MapTypeStyle) => {
+    const {featureType, elementType, stylers = []} = mapTypeStyle;
+
+    let styleString = '';
+
+    if (featureType) {
+      styleString += `|feature:${featureType}`;
+    }
+
+    if (elementType) {
+      styleString += `|element:${elementType}`;
+    }
+
+    for (const styler of stylers) {
+      Object.entries(styler).forEach(([name, value]) => {
+        styleString += `|${name}:${String(value).replace('#', '0x')}`;
+      });
+    }
+
+    return styleString;
+  });
+}
diff --git a/src/libraries/create-static-maps-url/assemble-marker-params.ts b/src/libraries/create-static-maps-url/assemble-marker-params.ts
new file mode 100644
index 0000000..2b2eb61
--- /dev/null
+++ b/src/libraries/create-static-maps-url/assemble-marker-params.ts
@@ -0,0 +1,77 @@
+import {StaticMapsMarker} from './types';
+
+/**
+ * Assembles marker parameters for static maps.
+ *
+ * This function takes an array of markers and groups them by their style properties.
+ * It then creates a string representation of these markers, including their styles and locations,
+ * which can be used as parameters for static map APIs.
+ *
+ * @param {StaticMapsMarker[]} [markers=[]] - An array of markers to be processed. Each marker can have properties such as color, label, size, scale, icon, anchor, and location.
+ * @returns {string[]} An array of strings, each representing a group of markers with their styles and locations.
+ *
+ * @example
+ * const markers = [
+ *   { color: 'blue', label: 'A', size: 'mid', location: '40.714728,-73.998672' },
+ *   { color: 'blue', label: 'B', size: 'mid', location: '40.714728,-73.998672' },
+ *   { icon: 'http://example.com/icon.png', location: { lat: 40.714728, lng: -73.998672 } }
+ * ];
+ * const params = assembleMarkerParams(markers);
+ * // Params will be an array of strings representing the marker parameters
+ * Example output: [
+ *   "|color:blue|label:A|size:mid|40.714728,-73.998672|40.714728,-73.998672",
+ *   "|icon:http://example.com/icon.png|40.714728,-73.998672"
+ * ]
+ */
+export function assembleMarkerParams(markers: StaticMapsMarker[] = []) {
+  const markerParams: Array<string> = [];
+
+  // Group markers by style
+  const markersByStyle = markers?.reduce(
+    (styles, marker) => {
+      const {color = 'red', label, size, scale, icon, anchor} = marker;
+
+      // Create a unique style key based on either icon properties or standard marker properties
+      const relevantProps = icon ? [icon, anchor, scale] : [color, label, size];
+      const key = relevantProps.filter(Boolean).join('-');
+
+      styles[key] = styles[key] || [];
+      styles[key].push(marker);
+      return styles;
+    },
+    {} as Record<string, StaticMapsMarker[]>
+  );
+
+  Object.values(markersByStyle ?? {}).forEach(markers => {
+    let markerParam: string = '';
+
+    const {icon} = markers[0];
+
+    // Create marker style from first marker in group since all markers share the same style.
+    Object.entries(markers[0]).forEach(([key, value]) => {
+      // Determine which properties to include based on whether marker uses custom icon
+      const relevantKeys = icon
+        ? ['icon', 'anchor', 'scale']
+        : ['color', 'label', 'size'];
+
+      if (relevantKeys.includes(key)) {
+        markerParam += `|${key}:${value}`;
+      }
+    });
+
+    // Add location coordinates for each marker in the style group
+    // Handles both string locations and lat/lng object formats.
+    for (const marker of markers) {
+      const location =
+        typeof marker.location === 'string'
+          ? marker.location
+          : `${marker.location.lat},${marker.location.lng}`;
+
+      markerParam += `|${location}`;
+    }
+
+    markerParams.push(markerParam);
+  });
+
+  return markerParams;
+}
diff --git a/src/libraries/create-static-maps-url/assemble-path-params.ts b/src/libraries/create-static-maps-url/assemble-path-params.ts
new file mode 100644
index 0000000..c88fff5
--- /dev/null
+++ b/src/libraries/create-static-maps-url/assemble-path-params.ts
@@ -0,0 +1,79 @@
+import {formatLocation} from './helpers';
+import {StaticMapsPath} from './types';
+
+/**
+ * Assembles path parameters for the Static Maps Api from an array of paths.
+ *
+ * This function groups paths by their style properties (color, weight, fillcolor, geodesic)
+ * and then constructs a string of path parameters for each group. Each path parameter string
+ * includes the style properties and the coordinates of the paths.
+ *
+ * @param {Array<StaticMapsPath>} [paths=[]] - An array of paths to be assembled into path parameters.
+ * @returns {Array<string>} An array of path parameter strings.
+ *
+ * @example
+ * const paths = [
+ *   {
+ *     color: 'red',
+ *     weight: 5,
+ *     coordinates: [
+ *       { lat: 40.714728, lng: -73.998672 },
+ *       { lat: 40.718217, lng: -73.998284 }
+ *     ]
+ *   }
+ * ];
+ *
+ * const pathParams = assemblePathParams(paths);
+ * Output: [
+ *    '|color:red|weight:5|40.714728,-73.998672|40.718217,-73.998284'
+ *  ]
+ */
+export function assemblePathParams(paths: Array<StaticMapsPath> = []) {
+  const pathParams: Array<string> = [];
+
+  // Group paths by their style properties (color, weight, fillcolor, geodesic)
+  // to combine paths with identical styles into single parameter strings
+  const pathsByStyle = paths?.reduce(
+    (styles, path) => {
+      const {color = 'default', weight, fillcolor, geodesic} = path;
+
+      // Create unique key for this style combination
+      const key = [color, weight, fillcolor, geodesic]
+        .filter(Boolean)
+        .join('-');
+
+      styles[key] = styles[key] || [];
+      styles[key].push(path);
+      return styles;
+    },
+    {} as Record<string, Array<StaticMapsPath>>
+  );
+
+  // Process each group of paths with identical styles
+  Object.values(pathsByStyle ?? {}).forEach(paths => {
+    let pathParam = '';
+
+    // Build style parameter string using properties from first path in group
+    // since all paths in this group share the same style
+    Object.entries(paths[0]).forEach(([key, value]) => {
+      if (['color', 'weight', 'fillcolor', 'geodesic'].includes(key)) {
+        pathParam += `|${key}:${value}`;
+      }
+    });
+
+    // Add location for all marker in style group
+    for (const path of paths) {
+      if (typeof path.coordinates === 'string') {
+        pathParam += `|${decodeURIComponent(path.coordinates)}`;
+      } else {
+        for (const location of path.coordinates) {
+          pathParam += `|${formatLocation(location)}`;
+        }
+      }
+    }
+
+    pathParams.push(pathParam);
+  });
+
+  return pathParams;
+}
diff --git a/src/libraries/create-static-maps-url/helpers.ts b/src/libraries/create-static-maps-url/helpers.ts
new file mode 100644
index 0000000..192f166
--- /dev/null
+++ b/src/libraries/create-static-maps-url/helpers.ts
@@ -0,0 +1,26 @@
+import {StaticMapsLocation} from './types';
+
+/**
+ * Formats a location into a string representation suitable for Google Static Maps API.
+ *
+ * @param location - The location to format, can be either a string or an object with lat/lng properties
+ * @returns A string representation of the location in the format "lat,lng" or the original string
+ *
+ * @example
+ * // Returns "40.714728,-73.998672"
+ * formatLocation({ lat: 40.714728, lng: -73.998672 })
+ *
+ * @example
+ * // Returns "New York, NY"
+ * formatLocation("New York, NY")
+ */
+export function formatLocation(location: StaticMapsLocation): string {
+  return typeof location === 'string'
+    ? location
+    : `${location.lat},${location.lng}`;
+}
+
+// Used for removing the leading pipe from the param string
+export function formatParam(string: string) {
+  return string.slice(1);
+}
diff --git a/src/libraries/create-static-maps-url/index.ts b/src/libraries/create-static-maps-url/index.ts
new file mode 100644
index 0000000..c85420b
--- /dev/null
+++ b/src/libraries/create-static-maps-url/index.ts
@@ -0,0 +1,140 @@
+import {assembleMarkerParams} from './assemble-marker-params';
+import {assemblePathParams} from './assemble-path-params';
+import {formatLocation, formatParam} from './helpers';
+
+import {StaticMapsApiOptions} from './types';
+import {assembleMapTypeStyles} from './assemble-map-type-styles';
+
+const STATIC_MAPS_BASE = 'https://maps.googleapis.com/maps/api/staticmap';
+
+/**
+ * Creates a URL for the Google Static Maps API with the specified parameters.
+ *
+ * @param {Object} options - The configuration options for the static map
+ * @param {string} options.apiKey - Your Google Maps API key (required)
+ * @param {number} options.width - The width of the map image in pixels (required)
+ * @param {number} options.height - The height of the map image in pixels (required)
+ * @param {StaticMapsLocation} [options.center] - The center point of the map (lat/lng or address)
+ * @param {number} [options.zoom] - The zoom level of the map (0-21)
+ * @param {1|2|4} [options.scale] - The resolution of the map (1, 2, or 4)
+ * @param {string} [options.format] - The image format (png, png8, png32, gif, jpg, jpg-baseline)
+ * @param {string} [options.mapType] - The type of map (roadmap, satellite, terrain, hybrid)
+ * @param {string} [options.language] - The language of the map labels
+ * @param {string} [options.region] - The region code for the map
+ * @param {string} [options.map_id] - The Cloud-based map style ID
+ * @param {StaticMapsMarker[]} [options.markers=[]] - Array of markers to display on the map
+ * @param {StaticMapsPath[]} [options.paths=[]] - Array of paths to display on the map
+ * @param {StaticMapsLocation[]} [options.visible=[]] - Array of locations that should be visible on the map
+ * @param {MapTypeStyle[]} [options.style=[]] - Array of style objects to customize the map appearance
+ *
+ * @returns {string} The complete Google Static Maps API URL
+ *
+ * @throws {Error} If API key is not provided
+ * @throws {Error} If width or height is not provided
+ *
+ * @example
+ * const url = createStaticMapsUrl({
+ *   apiKey: 'YOUR_API_KEY',
+ *   width: 600,
+ *   height: 400,
+ *   center: { lat: 40.714728, lng: -73.998672 },
+ *   zoom: 12,
+ *   markers: [
+ *     {
+ *       location: { lat: 40.714728, lng: -73.998672 },
+ *       color: 'red',
+ *       label: 'A'
+ *     }
+ *   ],
+ *   paths: [
+ *     {
+ *       coordinates: [
+ *         { lat: 40.714728, lng: -73.998672 },
+ *         { lat: 40.719728, lng: -73.991672 }
+ *       ],
+ *       color: '0x0000ff',
+ *       weight: 5
+ *     }
+ *   ],
+ *   style: [
+ *     {
+ *       featureType: 'road',
+ *       elementType: 'geometry',
+ *       stylers: [{color: '#00ff00'}]
+ *     }
+ *   ]
+ * });
+ *
+ * // Results in URL similar to:
+ * // https://maps.googleapis.com/maps/api/staticmap?key=YOUR_API_KEY
+ * // &size=600x400
+ * // &center=40.714728,-73.998672&zoom=12
+ * // &markers=color:red|label:A|40.714728,-73.998672
+ * // &path=color:0x0000ff|weight:5|40.714728,-73.998672|40.719728,-73.991672
+ * // &style=feature:road|element:geometry|color:0x00ff00
+ */
+export function createStaticMapsUrl({
+  apiKey,
+  width,
+  height,
+  center,
+  zoom,
+  scale,
+  format,
+  mapType,
+  language,
+  region,
+  map_id,
+  markers = [],
+  paths = [],
+  visible = [],
+  style = []
+}: StaticMapsApiOptions) {
+  if (!apiKey) throw new Error('API key is required');
+  if (!width || !height) throw new Error('Width and height are required');
+
+  const params: Record<string, string | number | null> = {
+    key: apiKey,
+    size: `${width}x${height}`,
+    ...(center && {center: formatLocation(center)}),
+    ...(zoom && {zoom}),
+    ...(scale && {scale}),
+    ...(format && {format}),
+    ...(mapType && {mapType}),
+    ...(language && {language}),
+    ...(region && {region}),
+    ...(map_id && {map_id})
+  };
+
+  const url = new URL(STATIC_MAPS_BASE);
+
+  // Params that don't need special handling
+  Object.entries(params).forEach(([key, value]) => {
+    url.searchParams.append(key, String(value));
+  });
+
+  // Assemble Markers
+  for (const markerParam of assembleMarkerParams(markers)) {
+    url.searchParams.append('markers', formatParam(markerParam));
+  }
+
+  // Assemble Paths
+  for (const pathParam of assemblePathParams(paths)) {
+    url.searchParams.append('path', formatParam(pathParam));
+  }
+
+  // Assemble visible locations
+  if (visible.length) {
+    url.searchParams.append(
+      'visible',
+      visible.map(location => formatLocation(location)).join('|')
+    );
+  }
+
+  // Assemble Map Type Styles
+  for (const styleString of assembleMapTypeStyles(style)) {
+    url.searchParams.append('style', formatParam(styleString));
+  }
+
+  return url.toString();
+}
diff --git a/src/libraries/create-static-maps-url/types.ts b/src/libraries/create-static-maps-url/types.ts
new file mode 100644
index 0000000..2171bbc
--- /dev/null
+++ b/src/libraries/create-static-maps-url/types.ts
@@ -0,0 +1,37 @@
+export type StaticMapsLocation = google.maps.LatLngLiteral | string;
+
+export type StaticMapsMarker = {
+  location: StaticMapsLocation;
+  color?: string;
+  size?: 'tiny' | 'mid' | 'small';
+  label?: string;
+  icon?: string;
+  anchor?: string;
+  scale?: 1 | 2 | 4;
+};
+
+export type StaticMapsPath = {
+  coordinates: Array<StaticMapsLocation> | string;
+  weight?: number;
+  color?: string;
+  fillcolor?: string;
+  geodesic?: boolean;
+};
+
+export type StaticMapsApiOptions = {
+  apiKey: string;
+  width: number;
+  height: number;
+  center?: StaticMapsLocation;
+  zoom?: number;
+  scale?: number;
+  format?: 'png' | 'png8' | 'png32' | 'gif' | 'jpg' | 'jpg-baseline';
+  mapType?: google.maps.MapTypeId;
+  language?: string;
+  region?: string;
+  map_id?: string;
+  markers?: Array<StaticMapsMarker>;
+  paths?: Array<StaticMapsPath>;
+  visible?: Array<StaticMapsLocation>;
+  style?: google.maps.MapTypeStyle[];
+};
diff --git a/src/server/index.ts b/src/server/index.ts
new file mode 100644
index 0000000..7a152d9
--- /dev/null
+++ b/src/server/index.ts
@@ -0,0 +1,3 @@
+/// <reference types="google.maps" preserve="true" />
+
+export * from '../components/static-map';

From d1e9afa8cfbc986b0cd412f2b64fe8117a58a4ca Mon Sep 17 00:00:00 2001
From: Malte Modrow <modrow@ubilabs.net>
Date: Mon, 9 Dec 2024 16:41:14 +0100
Subject: [PATCH 2/5] refactor: better consistency

---
 src/components/static-map.tsx                 |  4 +---
 src/libraries/create-static-maps-url/index.ts | 11 ++++++-----
 src/libraries/create-static-maps-url/types.ts |  2 +-
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/components/static-map.tsx b/src/components/static-map.tsx
index 7813068..fc923ba 100644
--- a/src/components/static-map.tsx
+++ b/src/components/static-map.tsx
@@ -13,9 +13,7 @@ export type StaticMapProps = {
 export const StaticMap = async (props: StaticMapProps) => {
   const {url} = props;
 
-  if (!url) {
-    return null;
-  }
+  if (!url) throw new Error('URL is required');
 
   return <img src={url} width="100%" />;
 };
diff --git a/src/libraries/create-static-maps-url/index.ts b/src/libraries/create-static-maps-url/index.ts
index c85420b..4d85da9 100644
--- a/src/libraries/create-static-maps-url/index.ts
+++ b/src/libraries/create-static-maps-url/index.ts
@@ -14,8 +14,9 @@ const STATIC_MAPS_BASE = 'https://maps.googleapis.com/maps/api/staticmap';
  * @param {string} options.apiKey - Your Google Maps API key (required)
  * @param {number} options.width - The width of the map image in pixels (required)
  * @param {number} options.height - The height of the map image in pixels (required)
- * @param {StaticMapsLocation} [options.center] - The center point of the map (lat/lng or address)
- * @param {number} [options.zoom] - The zoom level of the map (0-21)
+ * @param {StaticMapsLocation} [options.center] - The center point of the map (lat/lng or address).
+ *  Required if no markers or paths or "visible locations" are provided.
+ * @param {number} [options.zoom] - The zoom level of the map. Required if no markers or paths or "visible locations" are provided.
  * @param {1|2|4} [options.scale] - The resolution of the map (1, 2, or 4)
  * @param {string} [options.format] - The image format (png, png8, png32, gif, jpg, jpg-baseline)
  * @param {string} [options.mapType] - The type of map (roadmap, satellite, terrain, hybrid)
@@ -84,7 +85,7 @@ export function createStaticMapsUrl({
   mapType,
   language,
   region,
-  map_id,
+  mapId,
   markers = [],
   paths = [],
   visible = [],
@@ -100,10 +101,10 @@ export function createStaticMapsUrl({
     ...(zoom && {zoom}),
     ...(scale && {scale}),
     ...(format && {format}),
-    ...(mapType && {mapType}),
+    ...(mapType && {maptype: mapType}),
     ...(language && {language}),
     ...(region && {region}),
-    ...(map_id && {map_id})
+    ...(mapId && {map_id: mapId})
   };
 
   const url = new URL(STATIC_MAPS_BASE);
diff --git a/src/libraries/create-static-maps-url/types.ts b/src/libraries/create-static-maps-url/types.ts
index 2171bbc..1cc056c 100644
--- a/src/libraries/create-static-maps-url/types.ts
+++ b/src/libraries/create-static-maps-url/types.ts
@@ -29,7 +29,7 @@ export type StaticMapsApiOptions = {
   mapType?: google.maps.MapTypeId;
   language?: string;
   region?: string;
-  map_id?: string;
+  mapId?: string;
   markers?: Array<StaticMapsMarker>;
   paths?: Array<StaticMapsPath>;
   visible?: Array<StaticMapsLocation>;

From ae5712b78b90ab3de294b0b965115917e28aa506 Mon Sep 17 00:00:00 2001
From: Malte Modrow <modrow@ubilabs.net>
Date: Mon, 9 Dec 2024 16:42:21 +0100
Subject: [PATCH 3/5] test: add tests for createStaticMapsUrl

---
 .../__tests__/create-static-maps-url.test.ts  | 231 ++++++++++++++++++
 1 file changed, 231 insertions(+)
 create mode 100644 src/libraries/__tests__/create-static-maps-url.test.ts

diff --git a/src/libraries/__tests__/create-static-maps-url.test.ts b/src/libraries/__tests__/create-static-maps-url.test.ts
new file mode 100644
index 0000000..3716caa
--- /dev/null
+++ b/src/libraries/__tests__/create-static-maps-url.test.ts
@@ -0,0 +1,231 @@
+import {initialize} from '@googlemaps/jest-mocks';
+
+import {createStaticMapsUrl} from '../create-static-maps-url';
+
+const requiredParams = {
+  apiKey: 'test-api-key',
+  width: 600,
+  height: 400
+};
+
+beforeEach(() => {
+  initialize();
+});
+
+describe('createStaticMapsUrl', () => {
+  const API_KEY = 'test-api-key';
+
+  test('creates basic URL with required parameters', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      zoom: 12
+    });
+    expect(url).toMatch(
+      /^https:\/\/maps\.googleapis\.com\/maps\/api\/staticmap/
+    );
+    expect(url).toContain('center=40.714728%2C-73.998672');
+    expect(url).toContain('zoom=12');
+    expect(url).toContain('size=600x400');
+    expect(url).toContain(`key=${API_KEY}`);
+  });
+
+  test('includes map type', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      zoom: 12,
+      mapType: google.maps.MapTypeId.SATELLITE
+    });
+    expect(url).toContain('maptype=satellite');
+  });
+
+  test('handles single marker', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      markers: [{location: {lat: 40.714728, lng: -73.998672}}]
+    });
+
+    const markerParam = encodeURIComponent('40.714728,-73.998672');
+
+    expect(url).toContain(`markers=${markerParam}`);
+  });
+
+  test('handles multiple markers with same style', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      markers: [
+        {location: {lat: 40.714728, lng: -73.998672}, color: 'blue'},
+        {location: {lat: 41.715728, lng: -72.999672}, color: 'blue'}
+      ]
+    });
+
+    const markerParam = encodeURIComponent(
+      `color:blue|40.714728,-73.998672|41.715728,-72.999672`
+    );
+
+    expect(url).toContain(`markers=${markerParam}`);
+  });
+
+  test('handles multiple markers with different style', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      markers: [
+        {location: {lat: 40.714728, lng: -73.998672}, color: 'blue'},
+        {location: {lat: 41.715728, lng: -72.999672}, color: 'red'}
+      ]
+    });
+    const blueMarkerParam = encodeURIComponent(
+      `color:blue|40.714728,-73.998672`
+    );
+    const redMarkerParam = encodeURIComponent(`color:red|41.715728,-72.999672`);
+
+    expect(url).toContain(`markers=${blueMarkerParam}`);
+    expect(url).toContain(`markers=${redMarkerParam}`);
+  });
+
+  test('includes custom marker styles', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      markers: [
+        {
+          location: {lat: 40.714728, lng: -73.998672},
+          color: 'red',
+          label: 'A',
+          size: 'mid'
+        }
+      ]
+    });
+    expect(url).toContain(
+      'markers=color%3Ared%7Clabel%3AA%7Csize%3Amid%7C40.714728%2C-73.998672'
+    );
+  });
+
+  test('includes scale parameter', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      scale: 2
+    });
+    expect(url).toContain('scale=2');
+  });
+
+  test('includes format parameter', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      format: 'png32'
+    });
+    expect(url).toContain('format=png32');
+  });
+
+  test('includes language parameter', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      language: 'de'
+    });
+
+    expect(url).toContain(`language=de`);
+  });
+
+  test('includes region parameter', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      region: 'en'
+    });
+
+    expect(url).toContain(`region=en`);
+  });
+
+  test('includes map_id parameter', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      mapId: '8e0a97af9386fef'
+    });
+    const encodedMapId = encodeURIComponent('8e0a97af9386fef');
+    expect(url).toContain(`map_id=${encodedMapId}`);
+  });
+
+  test('handles single path', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      paths: [
+        {
+          coordinates: [
+            {lat: 40.737102, lng: -73.990318},
+            {lat: 40.749825, lng: -73.987963}
+          ],
+          color: 'blue',
+          weight: 5
+        }
+      ]
+    });
+    const encodedPath = encodeURIComponent(
+      'color:blue|weight:5|40.737102,-73.990318|40.749825,-73.987963'
+    );
+    expect(url).toContain(`path=${encodedPath}`);
+  });
+
+  test('handles multiple paths with different styles', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      paths: [
+        {
+          coordinates: [{lat: 40.737102, lng: -73.990318}, 'Hamburg, Germany'],
+          color: 'blue',
+          weight: 5
+        },
+        {
+          coordinates: [
+            {lat: 40.737102, lng: -73.990318},
+            {lat: 40.736102, lng: -73.989318}
+          ],
+          color: 'red',
+          weight: 2
+        }
+      ]
+    });
+    const encodedPath1 = encodeURIComponent(
+      'color:blue|weight:5|40.737102,-73.990318|Hamburg, Germany'
+    ).replace(/%20/g, '+');
+    const encodedPath2 = encodeURIComponent(
+      'color:red|weight:2|40.737102,-73.990318|40.736102,-73.989318'
+    );
+    expect(url).toContain(`path=${encodedPath1}`);
+    expect(url).toContain(`path=${encodedPath2}`);
+  });
+
+  test('includes style parameters', () => {
+    const url = createStaticMapsUrl({
+      ...requiredParams,
+      center: {lat: 40.714728, lng: -73.998672},
+      style: [
+        {
+          featureType: 'road',
+          elementType: 'geometry',
+          stylers: [{color: '#00ff00'}]
+        },
+        {
+          featureType: 'water',
+          elementType: 'geometry',
+          stylers: [{color: '#0000ff'}]
+        }
+      ]
+    });
+
+    const style1 = encodeURIComponent(
+      'feature:road|element:geometry|color:0x00ff00'
+    );
+    const style2 = encodeURIComponent(
+      'feature:water|element:geometry|color:0x0000ff'
+    );
+    expect(url).toContain(`style=${style1}`);
+    expect(url).toContain(`style=${style2}`);
+  });
+});

From 02ad34c016f9b8c1c1e8d360c7b34029c6d009e6 Mon Sep 17 00:00:00 2001
From: Malte Modrow <modrow@ubilabs.net>
Date: Mon, 9 Dec 2024 16:48:49 +0100
Subject: [PATCH 4/5] refactor: call formatParam in different place

---
 .../__tests__/create-static-maps-url.test.ts  |  6 ++-
 .../assemble-map-type-styles.ts               | 38 ++++++++++---------
 .../assemble-marker-params.ts                 |  7 ++--
 .../assemble-path-params.ts                   |  6 +--
 src/libraries/create-static-maps-url/index.ts |  6 +--
 5 files changed, 35 insertions(+), 28 deletions(-)

diff --git a/src/libraries/__tests__/create-static-maps-url.test.ts b/src/libraries/__tests__/create-static-maps-url.test.ts
index 3716caa..eb61c64 100644
--- a/src/libraries/__tests__/create-static-maps-url.test.ts
+++ b/src/libraries/__tests__/create-static-maps-url.test.ts
@@ -99,9 +99,11 @@ describe('createStaticMapsUrl', () => {
         }
       ]
     });
-    expect(url).toContain(
-      'markers=color%3Ared%7Clabel%3AA%7Csize%3Amid%7C40.714728%2C-73.998672'
+    const markerParam = encodeURIComponent(
+      'color:red|label:A|size:mid|40.714728,-73.998672'
     );
+
+    expect(url).toContain(`markers=${markerParam}`);
   });
 
   test('includes scale parameter', () => {
diff --git a/src/libraries/create-static-maps-url/assemble-map-type-styles.ts b/src/libraries/create-static-maps-url/assemble-map-type-styles.ts
index 83d016e..e997a22 100644
--- a/src/libraries/create-static-maps-url/assemble-map-type-styles.ts
+++ b/src/libraries/create-static-maps-url/assemble-map-type-styles.ts
@@ -1,3 +1,5 @@
+import {formatParam} from './helpers';
+
 /**
  * Converts an array of Google Maps style objects into an array of style strings
  * compatible with the Google Static Maps API.
@@ -16,7 +18,7 @@
  * // Returns: ["|feature:road|element:geometry|color:0xff0000|weight:1"]
  *
  * Each style string follows the format:
- * "|feature:{featureType}|element:{elementType}|{stylerName}:{stylerValue}"
+ * "feature:{featureType}|element:{elementType}|{stylerName}:{stylerValue}"
  *
  * Note: Color values with hexadecimal notation (#) are automatically converted
  * to the required 0x format for the Static Maps API.
@@ -24,25 +26,27 @@
 export function assembleMapTypeStyles(
   styles: Array<google.maps.MapTypeStyle>
 ): string[] {
-  return styles.map((mapTypeStyle: google.maps.MapTypeStyle) => {
-    const {featureType, elementType, stylers = []} = mapTypeStyle;
+  return styles
+    .map((mapTypeStyle: google.maps.MapTypeStyle) => {
+      const {featureType, elementType, stylers = []} = mapTypeStyle;
 
-    let styleString = '';
+      let styleString = '';
 
-    if (featureType) {
-      styleString += `|feature:${featureType}`;
-    }
+      if (featureType) {
+        styleString += `|feature:${featureType}`;
+      }
 
-    if (elementType) {
-      styleString += `|element:${elementType}`;
-    }
+      if (elementType) {
+        styleString += `|element:${elementType}`;
+      }
 
-    for (const styler of stylers) {
-      Object.entries(styler).forEach(([name, value]) => {
-        styleString += `|${name}:${String(value).replace('#', '0x')}`;
-      });
-    }
+      for (const styler of stylers) {
+        Object.entries(styler).forEach(([name, value]) => {
+          styleString += `|${name}:${String(value).replace('#', '0x')}`;
+        });
+      }
 
-    return styleString;
-  });
+      return styleString;
+    })
+    .map(formatParam);
 }
diff --git a/src/libraries/create-static-maps-url/assemble-marker-params.ts b/src/libraries/create-static-maps-url/assemble-marker-params.ts
index 2b2eb61..a37919f 100644
--- a/src/libraries/create-static-maps-url/assemble-marker-params.ts
+++ b/src/libraries/create-static-maps-url/assemble-marker-params.ts
@@ -1,3 +1,4 @@
+import {formatParam} from './helpers';
 import {StaticMapsMarker} from './types';
 
 /**
@@ -19,8 +20,8 @@ import {StaticMapsMarker} from './types';
  * const params = assembleMarkerParams(markers);
  * // Params will be an array of strings representing the marker parameters
  * Example output: [
- *   "|color:blue|label:A|size:mid|40.714728,-73.998672|40.714728,-73.998672",
- *   "|icon:http://example.com/icon.png|40.714728,-73.998672"
+ *   "color:blue|label:A|size:mid|40.714728,-73.998672|40.714728,-73.998672",
+ *   "icon:http://example.com/icon.png|40.714728,-73.998672"
  * ]
  */
 export function assembleMarkerParams(markers: StaticMapsMarker[] = []) {
@@ -73,5 +74,5 @@ export function assembleMarkerParams(markers: StaticMapsMarker[] = []) {
     markerParams.push(markerParam);
   });
 
-  return markerParams;
+  return markerParams.map(formatParam);
 }
diff --git a/src/libraries/create-static-maps-url/assemble-path-params.ts b/src/libraries/create-static-maps-url/assemble-path-params.ts
index c88fff5..a24c5fe 100644
--- a/src/libraries/create-static-maps-url/assemble-path-params.ts
+++ b/src/libraries/create-static-maps-url/assemble-path-params.ts
@@ -1,4 +1,4 @@
-import {formatLocation} from './helpers';
+import {formatLocation, formatParam} from './helpers';
 import {StaticMapsPath} from './types';
 
 /**
@@ -25,7 +25,7 @@ import {StaticMapsPath} from './types';
  *
  * const pathParams = assemblePathParams(paths);
  * Output: [
- *    '|color:red|weight:5|40.714728,-73.998672|40.718217,-73.998284'
+ *    'color:red|weight:5|40.714728,-73.998672|40.718217,-73.998284'
  *  ]
  */
 export function assemblePathParams(paths: Array<StaticMapsPath> = []) {
@@ -75,5 +75,5 @@ export function assemblePathParams(paths: Array<StaticMapsPath> = []) {
     pathParams.push(pathParam);
   });
 
-  return pathParams;
+  return pathParams.map(formatParam);
 }
diff --git a/src/libraries/create-static-maps-url/index.ts b/src/libraries/create-static-maps-url/index.ts
index 4d85da9..0fb0ca3 100644
--- a/src/libraries/create-static-maps-url/index.ts
+++ b/src/libraries/create-static-maps-url/index.ts
@@ -116,12 +116,12 @@ export function createStaticMapsUrl({
 
   // Assemble Markers
   for (const markerParam of assembleMarkerParams(markers)) {
-    url.searchParams.append('markers', formatParam(markerParam));
+    url.searchParams.append('markers', markerParam);
   }
 
   // Assemble Paths
   for (const pathParam of assemblePathParams(paths)) {
-    url.searchParams.append('path', formatParam(pathParam));
+    url.searchParams.append('path', pathParam);
   }
 
   // Assemble visible locations
@@ -134,7 +134,7 @@ export function createStaticMapsUrl({
 
   // Assemble Map Type Styles
   for (const styleString of assembleMapTypeStyles(style)) {
-    url.searchParams.append('style', formatParam(styleString));
+    url.searchParams.append('style', styleString);
   }
 
   return url.toString();

From 95df99cfd312ed41044f2f9f9926d16a76dc30d7 Mon Sep 17 00:00:00 2001
From: Malte Modrow <modrow@ubilabs.net>
Date: Thu, 12 Dec 2024 16:24:11 +0100
Subject: [PATCH 5/5] feat(static-map): add example and documentation page

---
 docs/api-reference/components/static-map.md   | 229 ++++++++++++++++++
 docs/table-of-contents.json                   |   3 +-
 examples/examples.css                         |  27 +++
 examples/static-map/README.md                 |  35 +++
 examples/static-map/index.html                |  31 +++
 examples/static-map/package.json              |  14 ++
 examples/static-map/src/app.tsx               |  42 ++++
 examples/static-map/src/control-panel.tsx     |  25 ++
 examples/static-map/src/static-map-1.tsx      |  19 ++
 examples/static-map/src/static-map-2.tsx      |  44 ++++
 examples/static-map/src/static-map-3.tsx      |  32 +++
 examples/static-map/src/static-map-4.tsx      |  45 ++++
 examples/static-map/vite.config.js            |  17 ++
 src/components/static-map.tsx                 |   7 +-
 .../assemble-marker-params.ts                 |   1 +
 src/libraries/create-static-maps-url/index.ts |   2 +-
 website/src/examples-sidebar.js               |   3 +-
 website/src/examples/static-map.mdx           |   5 +
 website/static/images/examples/static-map.jpg | Bin 0 -> 108940 bytes
 19 files changed, 575 insertions(+), 6 deletions(-)
 create mode 100644 docs/api-reference/components/static-map.md
 create mode 100644 examples/static-map/README.md
 create mode 100644 examples/static-map/index.html
 create mode 100644 examples/static-map/package.json
 create mode 100644 examples/static-map/src/app.tsx
 create mode 100644 examples/static-map/src/control-panel.tsx
 create mode 100644 examples/static-map/src/static-map-1.tsx
 create mode 100644 examples/static-map/src/static-map-2.tsx
 create mode 100644 examples/static-map/src/static-map-3.tsx
 create mode 100644 examples/static-map/src/static-map-4.tsx
 create mode 100644 examples/static-map/vite.config.js
 create mode 100644 website/src/examples/static-map.mdx
 create mode 100644 website/static/images/examples/static-map.jpg

diff --git a/docs/api-reference/components/static-map.md b/docs/api-reference/components/static-map.md
new file mode 100644
index 0000000..f553d22
--- /dev/null
+++ b/docs/api-reference/components/static-map.md
@@ -0,0 +1,229 @@
+# `<StaticMap>` Component
+
+React component and utility function to create and render [Google Static Maps][gmp-static-map] images. This implementation provides both a React component for rendering and a URL generation utility that supports all Google Static Maps API features. The main purpose of the utility function is to enable 'url-signing' in various
+server environments.
+
+The main parameters to control the map are `center`,
+`zoom`, `width` and `height`. With a plain map all of these are required for the map to show. There are cases where `center` and `zoom` can be omitted and the viewport can be automatically be determined from other data. This is the case when having markers, paths or other `visible` locations which can form an automatic bounding box for the map view.
+
+Parameters that are always required are `apiKey`, `width` and `height`.
+
+```tsx
+import {StaticMap, createStaticMapsUrl} from '@vis.gl/react-google-maps';
+
+const App = () => {
+  let staticMapsUrl = createStaticMapsUrl({
+    apiKey: 'YOUR API KEY',
+    width: 512,
+    height: 512,
+    center: {lat: 53.555570296010295, lng: 10.008892744638956},
+    zoom: 15
+  });
+
+  // Recommended url-signing when in a server environment.
+  staticMapsUrl = someServerSigningCode(
+    staticMapsUrl,
+    process.env.MAPS_SIGNING_SECRET
+  );
+
+  return <StaticMap url={staticMapsUrl} />;
+};
+```
+
+More on URL signing and digital signatures [here](#digital-signature).
+
+## Props
+
+The `StaticMap` component only has one `url` prop. The recommended way to generate the url is to use the `createStaticMapsUrl` helper function.
+
+### Required
+
+#### `url`: string
+
+An url which can be consumed by the Google Maps Static Api.
+
+### Optional
+
+#### `className`: string
+
+A class name that will be attached to the `img` tag.
+
+## `createStaticMapsUrl` options
+
+:::note
+
+Some explanations and syntax migh differ slighty from the official documentation since the Google documentation focuses on building and URL which has
+been abstracted here in the helper function for better developer experience
+
+:::
+
+For more details about API options see the [get started][get-started] guide in the Google documentation.
+
+### Required
+
+#### `apiKey`: string
+
+The Google Maps Api key.
+
+#### `width`: number
+
+Width of the image. Maps smaller than 180 pixels in width will display a reduced-size Google logo. This parameter is affected by the scale parameter; the final output size is the product of the size and scale values.
+
+#### `height`: number
+
+Height of the image. This parameter is affected by the scale parameter; the final output size is the product of the size and scale values.
+
+### Optional
+
+#### `center`: [StaticMapsLocation](#staticmapslocation)
+
+(required if no markers, paths or visible locations are present) Defines the center of the map, equidistant from all edges of the map. This parameter takes a location as either [`google.maps.LatLngLiteral`][gmp-ll] or a string address (e.g. "city hall, new york, ny") identifying a unique location on the face of the earth.
+
+#### `zoom`: number
+
+(required if no markers, paths or visible locations are present) Defines the zoom level of the map, which determines the magnification level of the map. This parameter takes a numerical value corresponding to the zoom level of the region desired.
+
+#### `scale`: number
+
+Affects the number of pixels that are returned. scale=2 returns twice as many pixels as scale=1 while retaining the same coverage area and level of detail (i.e. the contents of the map don't change). This is useful when developing for high-resolution displays. The default value is 1. Accepted values are 1 and 2
+
+#### `format`: 'png' | 'png8' | 'png32' | 'gif' | 'jpg' | 'jpg-baseline'
+
+Defines the format of the resulting image. By default, the Maps Static API creates PNG images. There are several possible formats including GIF, JPEG and PNG types. Which format you use depends on how you intend to present the image. JPEG typically provides greater compression, while GIF and PNG provide greater detail
+
+#### `mapType`: [google.maps.MapTypeId][gmp-map-type-id]
+
+Defines the type of map to construct. There are several possible maptype values, including roadmap, satellite, hybrid, and terrain.
+
+#### `language`: string
+
+Defines the language to use for display of labels on map tiles. Note that this parameter is only supported for some country tiles; if the specific language requested is not supported for the tile set, then the default language for that tileset will be used.
+
+#### `region`: string
+
+Defines the appropriate borders to display, based on geo-political sensitivities. Accepts a region code specified as a two-character ccTLD ('top-level domain') value
+
+#### `mapId`: string
+
+Specifies the identifier for a specific map. The Map ID associates a map with a particular style or feature, and must belong to the same project as the API key used to initialize the map.
+
+#### `markers`: [StaticMapsMarker[]](#staticmapsmarker)
+
+Defines markers that should be visible on the map.
+
+#### `paths`: [StaticMapsPath[]](#staticmapspath)
+
+Defines paths that should be shown on the map.
+
+#### `visible`: [StaticMapsLocation[]](#staticmapslocation)
+
+Specifies one or more locations that should remain visible on the map, though no markers or other indicators will be displayed. Use this parameter to ensure that certain features or map locations are shown on the Maps Static API.
+
+#### `style`: [google.maps.MapTypeStyle[]][gmp-map-type-style]
+
+Defines a custom style to alter the presentation of a specific feature (roads, parks, and other features) of the map. This parameter takes feature and element arguments identifying the features to style, and a set of style operations to apply to the selected features. See [style reference][gmp-style-ref] for more information.
+
+## Digital Signature
+
+:::warning
+
+Please only use URL signing on the server and keep your URL signing secret secure. Do not pass it in any requests, store it on any websites, or post it to any public forum. Anyone obtaining your URL signing secret could spoof requests using your identity.
+
+:::
+It is recommended to use a [digital signature][digital-signature] with your Static Maps Api requests.
+
+Digital signatures are generated using a URL signing secret, which is available on the Google Cloud Console. This secret is essentially a private key, only shared between you and Google, and is unique to your project.
+
+The signing process uses an encryption algorithm to combine the URL and your shared secret. The resulting unique signature allows our servers to verify that any site generating requests using your API key is authorized to do so.
+
+- Step 1: [Get your URL signing secret][sign-secret]
+- Step 2: Construct an unsigned request with the `createStaticMapUrl` helper.
+- Step 3: [Generate the signed request][generate-signed] | [Sample code for URL signing][sample-code]
+
+Google also provides a package [`@googlemaps/url-signature`][url-signature] for URL signing. Another example could look like this. Here in a Next.js environment.
+
+```tsx
+import 'server-only';
+
+import {signUrl} from '@googlemaps/url-signature';
+
+export function signStaticMapsUrl(url: string, secret: string): string {
+  return signUrl(url, secret).toString();
+}
+```
+
+When the signing process is setup, you can then [limit the unsigned request][limit-unsigned] to prevent abuse of your api key
+
+## Types
+
+### StaticMapsLocation
+
+Reference: [`google.maps.LatLngLiteral`][gmp-ll]
+
+```tsx
+type StaticMapsLocation = google.maps.LatLngLiteral | string;
+```
+
+### StaticMapsMarker
+
+- For `color`, `size`, `label` see [marker styles][gmp-marker-styles].
+- For `icon`, `anchor` and `scaling` see [custom icons][gmp-custom-icons].
+
+```tsx
+type StaticMapsMarker = {
+  location: google.maps.LatLngLiteral | string;
+  color?: string;
+  size?: 'tiny' | 'mid' | 'small';
+  label?: string;
+  icon?: string;
+  anchor?: string;
+  scale?: 1 | 2 | 4;
+};
+```
+
+### StaticMapsPath
+
+For style options see [Path styles][gmp-path-styles].
+
+`coordinates` can either bei an array of locations/addresses or it can be an [encoded polyline][gmp-encoded-polyline]. Note that the encoded polyline needs an `enc:` prefix.
+
+```tsx
+type StaticMapsPath = {
+  coordinates: Array<google.maps.LatLngLiteral | string> | string;
+  weight?: number;
+  color?: string;
+  fillcolor?: string;
+  geodesic?: boolean;
+};
+```
+
+## Examples
+
+Usage examples for many of the API options can be found [here][usage-examples]
+
+## Source
+
+[`./src/components/static-map`][static-map-source]\
+[`./src/libraries/create-static-maps-url/index`][create-static-map-url-source]\
+[`./src/libraries/create-static-maps-url/types`][create-static-map-url-types]
+
+[gmp-static-map]: https://developers.google.com/maps/documentation/maps-static
+[static-map-source]: https://github.com/visgl/react-google-maps/tree/main/src/components/static-map
+[create-static-map-url-source]: https://github.com/visgl/react-google-maps/tree/main/src/libraries/create-static-maps-url/index.ts
+[create-static-map-url-types]: https://github.com/visgl/react-google-maps/tree/main/src/libraries/create-static-maps-url/types
+[gmp-map-type-id]: https://developers.google.com/maps/documentation/javascript/reference/map#MapTypeId
+[gmp-ll]: https://developers.google.com/maps/documentation/javascript/reference/coordinates#LatLngLiteral
+[gmp-map-type-style]: https://developers.google.com/maps/documentation/javascript/reference/map#MapTypeStyle
+[usage-examples]: https://github.com/visgl/react-google-maps/tree/main/examples/static-map
+[get-started]: https://developers.google.com/maps/documentation/maps-static/start
+[sign-secret]: https://developers.google.com/maps/documentation/maps-static/digital-signature#get-secret
+[gmp-encoded-polyline]: https://developers.google.com/maps/documentation/maps-static/start#EncodedPolylines
+[gmp-path-styles]: https://developers.google.com/maps/documentation/maps-static/start#PathStyles
+[gmp-marker-styles]: https://developers.google.com/maps/documentation/maps-static/start#MarkerStyles
+[gmp-custom-icons]: https://developers.google.com/maps/documentation/maps-static/start#CustomIcons
+[limit-unsigned]: https://developers.google.com/maps/documentation/maps-static/digital-signature#limit-unsigned-requests
+[url-signature]: https://www.npmjs.com/package/@googlemaps/url-signature
+[generate-signed]: https://developers.google.com/maps/documentation/maps-static/digital-signature#generate-signed-request
+[sample-code]: https://developers.google.com/maps/documentation/maps-static/digital-signature#sample-code-for-url-signing
+[digital-signature]: https://developers.google.com/maps/documentation/maps-static/digital-signature
+[gmp-style-ref]: https://developers.google.com/maps/documentation/maps-static/style-reference
diff --git a/docs/table-of-contents.json b/docs/table-of-contents.json
index dcd020e..07a5ab0 100644
--- a/docs/table-of-contents.json
+++ b/docs/table-of-contents.json
@@ -39,7 +39,8 @@
           "api-reference/components/info-window",
           "api-reference/components/marker",
           "api-reference/components/advanced-marker",
-          "api-reference/components/pin"
+          "api-reference/components/pin",
+          "api-reference/components/static-map"
         ]
       },
       {
diff --git a/examples/examples.css b/examples/examples.css
index 4aaa6b3..060af36 100644
--- a/examples/examples.css
+++ b/examples/examples.css
@@ -126,3 +126,30 @@ html[data-theme='dark'] .gm-style {
   opacity: 0.5;
   cursor: default;
 }
+
+.static-map-grid,
+.static-map-grid * {
+  box-sizing: border-box;
+}
+
+.static-map-grid {
+  display: grid;
+  grid-template-rows: 1fr 1fr;
+  grid-template-columns: 1fr 1fr;
+  height: 100%;
+  width: 100%;
+  gap: 16px;
+  padding: 16px;
+  background: darkgray;
+}
+
+.static-map-grid .map-container {
+  position: relative;
+}
+
+.static-map-grid .map {
+  object-fit: contain;
+  position: absolute;
+  height: 100%;
+  width: 100%;
+}
diff --git a/examples/static-map/README.md b/examples/static-map/README.md
new file mode 100644
index 0000000..294e7d0
--- /dev/null
+++ b/examples/static-map/README.md
@@ -0,0 +1,35 @@
+# Static Map Example
+
+This is an example to show how to use the `Static Map` component.
+
+## Google Maps Platform API Key
+
+This example does not come with an API key. Running the examples locally requires a valid API key for the Google Maps Platform.
+See [the official documentation][get-api-key] on how to create and configure your own key.
+
+The API key has to be provided via an environment variable `GOOGLE_MAPS_API_KEY`. This can be done by creating a
+file named `.env` in the example directory with the following content:
+
+```shell title=".env"
+GOOGLE_MAPS_API_KEY="<YOUR API KEY HERE>"
+```
+
+If you are on the CodeSandbox playground you can also choose to [provide the API key like this](https://codesandbox.io/docs/learn/environment/secrets)
+
+## Development
+
+Go into the example-directory and run
+
+```shell
+npm install
+```
+
+To start the example with the local library run
+
+```shell
+npm run start-local
+```
+
+The regular `npm start` task is only used for the standalone versions of the example (CodeSandbox for example)
+
+[get-api-key]: https://developers.google.com/maps/documentation/javascript/get-api-key
diff --git a/examples/static-map/index.html b/examples/static-map/index.html
new file mode 100644
index 0000000..72dcb2c
--- /dev/null
+++ b/examples/static-map/index.html
@@ -0,0 +1,31 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1.0, user-scalable=no" />
+    <title>Static Map Example</title>
+    <meta name="description" content="Static Map Example" />
+    <style>
+      body {
+        margin: 0;
+        font-family: sans-serif;
+      }
+      #app {
+        width: 100vw;
+        height: 100vh;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module">
+      import '@vis.gl/react-google-maps/examples.css';
+      import '@vis.gl/react-google-maps/examples.js';
+      import {renderToDom} from './src/app';
+
+      renderToDom(document.querySelector('#app'));
+    </script>
+  </body>
+</html>
diff --git a/examples/static-map/package.json b/examples/static-map/package.json
new file mode 100644
index 0000000..05765f9
--- /dev/null
+++ b/examples/static-map/package.json
@@ -0,0 +1,14 @@
+{
+  "type": "module",
+  "dependencies": {
+    "@vis.gl/react-google-maps": "latest",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "vite": "^5.0.4"
+  },
+  "scripts": {
+    "start": "vite",
+    "start-local": "vite --config ../vite.config.local.js",
+    "build": "vite build"
+  }
+}
diff --git a/examples/static-map/src/app.tsx b/examples/static-map/src/app.tsx
new file mode 100644
index 0000000..d40d48b
--- /dev/null
+++ b/examples/static-map/src/app.tsx
@@ -0,0 +1,42 @@
+import React from 'react';
+import {createRoot} from 'react-dom/client';
+
+import StaticMap1 from './static-map-1';
+import StaticMap2 from './static-map-2';
+import StaticMap3 from './static-map-3';
+import StaticMap4 from './static-map-4';
+
+import ControlPanel from './control-panel';
+
+function App() {
+  return (
+    <div className="static-map-grid">
+      <div className="map-container">
+        <StaticMap1 />
+      </div>
+      <div className="map-container">
+        <StaticMap2 />
+      </div>
+      <div className="map-container">
+        <StaticMap3 />
+      </div>
+      <div className="map-container">
+        <StaticMap4 />
+      </div>
+
+      <ControlPanel />
+    </div>
+  );
+}
+
+export default App;
+
+export function renderToDom(container: HTMLElement) {
+  const root = createRoot(container);
+
+  root.render(
+    <React.StrictMode>
+      <App />
+    </React.StrictMode>
+  );
+}
diff --git a/examples/static-map/src/control-panel.tsx b/examples/static-map/src/control-panel.tsx
new file mode 100644
index 0000000..9998d65
--- /dev/null
+++ b/examples/static-map/src/control-panel.tsx
@@ -0,0 +1,25 @@
+import * as React from 'react';
+
+function ControlPanel() {
+  return (
+    <div className="control-panel">
+      <h3>Static Map</h3>
+      <p>Static Map usage examples.</p>
+      <div className="links">
+        <a
+          href="https://codesandbox.io/s/github/visgl/react-google-maps/tree/main/examples/static-map"
+          target="_new">
+          Try on CodeSandbox ↗
+        </a>
+
+        <a
+          href="https://github.com/visgl/react-google-maps/tree/main/examples/static-map"
+          target="_new">
+          View Code ↗
+        </a>
+      </div>
+    </div>
+  );
+}
+
+export default React.memo(ControlPanel);
diff --git a/examples/static-map/src/static-map-1.tsx b/examples/static-map/src/static-map-1.tsx
new file mode 100644
index 0000000..e1f286c
--- /dev/null
+++ b/examples/static-map/src/static-map-1.tsx
@@ -0,0 +1,19 @@
+import React from 'react';
+import {StaticMap, createStaticMapsUrl} from '@vis.gl/react-google-maps';
+
+const API_KEY =
+  globalThis.GOOGLE_MAPS_API_KEY ?? (process.env.GOOGLE_MAPS_API_KEY as string);
+
+export default function StaticMap1() {
+  const staticMapsUrl = createStaticMapsUrl({
+    apiKey: API_KEY,
+    scale: 2,
+    width: 600,
+    height: 600,
+    center: {lat: 53.555570296010295, lng: 10.008892744638956},
+    zoom: 8,
+    language: 'en'
+  });
+
+  return <StaticMap className="map" url={staticMapsUrl} />;
+}
diff --git a/examples/static-map/src/static-map-2.tsx b/examples/static-map/src/static-map-2.tsx
new file mode 100644
index 0000000..cfafd37
--- /dev/null
+++ b/examples/static-map/src/static-map-2.tsx
@@ -0,0 +1,44 @@
+import React from 'react';
+import {StaticMap, createStaticMapsUrl} from '@vis.gl/react-google-maps';
+
+const API_KEY =
+  globalThis.GOOGLE_MAPS_API_KEY ?? (process.env.GOOGLE_MAPS_API_KEY as string);
+
+export default function StaticMap2() {
+  const staticMapsUrl = createStaticMapsUrl({
+    apiKey: API_KEY,
+    scale: 2,
+    width: 600,
+    height: 600,
+    mapId: '8e0a97af9386fef',
+    format: 'png',
+    markers: [
+      {
+        location: 'Hamburg, Germany',
+        color: '0xff1493',
+        label: 'H',
+        size: 'small'
+      },
+      {
+        location: {lat: 52.5, lng: 10},
+        color: 'blue',
+        label: 'H'
+      },
+      {
+        location: 'Berlin, Germany',
+        color: 'orange',
+        icon: 'http://tinyurl.com/jrhlvu6',
+        anchor: 'center',
+        label: 'B',
+        scale: 2
+      },
+      {
+        location: 'Essen, Germany',
+        color: 'purple'
+      }
+    ],
+    visible: ['Germany']
+  });
+
+  return <StaticMap className="map" url={staticMapsUrl} />;
+}
diff --git a/examples/static-map/src/static-map-3.tsx b/examples/static-map/src/static-map-3.tsx
new file mode 100644
index 0000000..00093c9
--- /dev/null
+++ b/examples/static-map/src/static-map-3.tsx
@@ -0,0 +1,32 @@
+import React from 'react';
+import {StaticMap, createStaticMapsUrl} from '@vis.gl/react-google-maps';
+
+const API_KEY =
+  globalThis.GOOGLE_MAPS_API_KEY ?? (process.env.GOOGLE_MAPS_API_KEY as string);
+
+export default function StaticMap3() {
+  const staticMapsUrl = createStaticMapsUrl({
+    apiKey: API_KEY,
+    scale: 2,
+    width: 600,
+    height: 600,
+    mapType: 'hybrid',
+    format: 'jpg',
+    paths: [
+      {
+        color: '0xff1493',
+        fillcolor: '0xffff00',
+        coordinates: [
+          {lat: 52.5, lng: 10},
+          'Berlin, Germany',
+          'Hamburg, Germany'
+        ]
+      },
+      {
+        coordinates: [{lat: 52.5, lng: 10}, 'Leipzig, Germany']
+      }
+    ]
+  });
+
+  return <StaticMap className="map" url={staticMapsUrl} />;
+}
diff --git a/examples/static-map/src/static-map-4.tsx b/examples/static-map/src/static-map-4.tsx
new file mode 100644
index 0000000..eab2923
--- /dev/null
+++ b/examples/static-map/src/static-map-4.tsx
@@ -0,0 +1,45 @@
+import React from 'react';
+import {StaticMap, createStaticMapsUrl} from '@vis.gl/react-google-maps';
+
+const API_KEY =
+  globalThis.GOOGLE_MAPS_API_KEY ?? (process.env.GOOGLE_MAPS_API_KEY as string);
+
+export default function StaticMap4() {
+  const staticMapsUrl = createStaticMapsUrl({
+    apiKey: API_KEY,
+    scale: 2,
+    width: 600,
+    height: 600,
+    paths: [
+      {
+        color: '0xff00ff',
+        fillcolor: '0xffff00',
+        coordinates:
+          'enc:}zswFtikbMjJzZ|RdPfZ}DxWvBjWpF~IvJnEvBrMvIvUpGtQpFhOQdKpz@bIx{A|PfYlvApz@bl@tcAdTpGpVwQtX}i@|Gen@lCeAda@bjA`q@v}@rfAbjA|EwBpbAd_@he@hDbu@uIzWcWtZoTdImTdIwu@tDaOXw_@fc@st@~VgQ|[uPzNtA`LlEvHiYyLs^nPhCpG}SzCNwHpz@cEvXg@bWdG`]lL~MdTmEnCwJ[iJhOae@nCm[`Aq]qE_pAaNiyBuDurAuB}}Ay`@|EKv_@?|[qGji@lAhYyH`@Xiw@tBerAs@q]jHohAYkSmW?aNoaAbR}LnPqNtMtIbRyRuDef@eT_z@mW_Nm|B~j@zC~hAyUyJ_U{Z??cPvg@}s@sHsc@_z@cj@kp@YePoNyYyb@_iAyb@gBw^bOokArcA}GwJuzBre@i\\tf@sZnd@oElb@hStW{]vv@??kz@~vAcj@zKa`Atf@uQj_Aee@pU_UrcA'
+      }
+    ],
+    style: [
+      {
+        featureType: 'road.local',
+        elementType: 'geometry',
+        stylers: [{color: '#00ff00'}]
+      },
+      {
+        featureType: 'landscape',
+        elementType: 'geometry.fill',
+        stylers: [{color: '#222222'}]
+      },
+      {
+        elementType: 'labels',
+        stylers: [{invert_lightness: true}]
+      },
+      {
+        featureType: 'road.arterial',
+        elementType: 'labels',
+        stylers: [{invert_lightness: false}]
+      }
+    ]
+  });
+
+  return <StaticMap className="map" url={staticMapsUrl} />;
+}
diff --git a/examples/static-map/vite.config.js b/examples/static-map/vite.config.js
new file mode 100644
index 0000000..522c6cb
--- /dev/null
+++ b/examples/static-map/vite.config.js
@@ -0,0 +1,17 @@
+import {defineConfig, loadEnv} from 'vite';
+
+export default defineConfig(({mode}) => {
+  const {GOOGLE_MAPS_API_KEY = ''} = loadEnv(mode, process.cwd(), '');
+
+  return {
+    define: {
+      'process.env.GOOGLE_MAPS_API_KEY': JSON.stringify(GOOGLE_MAPS_API_KEY)
+    },
+    resolve: {
+      alias: {
+        '@vis.gl/react-google-maps/examples.js':
+          'https://visgl.github.io/react-google-maps/scripts/examples.js'
+      }
+    }
+  };
+});
diff --git a/src/components/static-map.tsx b/src/components/static-map.tsx
index fc923ba..ae57d77 100644
--- a/src/components/static-map.tsx
+++ b/src/components/static-map.tsx
@@ -8,12 +8,13 @@ export * from '../libraries/create-static-maps-url/types';
  */
 export type StaticMapProps = {
   url: string;
+  className?: string;
 };
 
-export const StaticMap = async (props: StaticMapProps) => {
-  const {url} = props;
+export const StaticMap = (props: StaticMapProps) => {
+  const {url, className} = props;
 
   if (!url) throw new Error('URL is required');
 
-  return <img src={url} width="100%" />;
+  return <img className={className} src={url} width="100%" />;
 };
diff --git a/src/libraries/create-static-maps-url/assemble-marker-params.ts b/src/libraries/create-static-maps-url/assemble-marker-params.ts
index a37919f..3498afb 100644
--- a/src/libraries/create-static-maps-url/assemble-marker-params.ts
+++ b/src/libraries/create-static-maps-url/assemble-marker-params.ts
@@ -21,6 +21,7 @@ import {StaticMapsMarker} from './types';
  * // Params will be an array of strings representing the marker parameters
  * Example output: [
  *   "color:blue|label:A|size:mid|40.714728,-73.998672|40.714728,-73.998672",
+ *   "color:blue|label:B|size:mid|40.714728,-73.998672|40.714728,-73.998672",
  *   "icon:http://example.com/icon.png|40.714728,-73.998672"
  * ]
  */
diff --git a/src/libraries/create-static-maps-url/index.ts b/src/libraries/create-static-maps-url/index.ts
index 0fb0ca3..e18205d 100644
--- a/src/libraries/create-static-maps-url/index.ts
+++ b/src/libraries/create-static-maps-url/index.ts
@@ -1,6 +1,6 @@
 import {assembleMarkerParams} from './assemble-marker-params';
 import {assemblePathParams} from './assemble-path-params';
-import {formatLocation, formatParam} from './helpers';
+import {formatLocation} from './helpers';
 
 import {StaticMapsApiOptions} from './types';
 import {assembleMapTypeStyles} from './assemble-map-type-styles';
diff --git a/website/src/examples-sidebar.js b/website/src/examples-sidebar.js
index 688283a..a25f989 100644
--- a/website/src/examples-sidebar.js
+++ b/website/src/examples-sidebar.js
@@ -26,7 +26,8 @@ const sidebars = {
         'directions',
         'deckgl-overlay',
         'map-3d',
-        'extended-component-library'
+        'extended-component-library',
+        'static-map'
       ]
     }
   ]
diff --git a/website/src/examples/static-map.mdx b/website/src/examples/static-map.mdx
new file mode 100644
index 0000000..91daf33
--- /dev/null
+++ b/website/src/examples/static-map.mdx
@@ -0,0 +1,5 @@
+# Static Map
+
+import App from 'website-examples/static-map/src/app';
+
+<App />
diff --git a/website/static/images/examples/static-map.jpg b/website/static/images/examples/static-map.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..603abc694862cff8b1dc2406357e59efa0abd9d7
GIT binary patch
literal 108940
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%0Adu=|DUu=iFn(j+ky#{sY
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
M6i@+06i^5M*%F*L)&Kwi

literal 0
HcmV?d00001