defra_ruby_map 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a2f98d96f22c559bf065e71a385e2e6c44e15a3f88849472894991d97bc8d84
+  data.tar.gz: 2c06e945bfc6341124f8a3d1de8660059a2e152bba0272322edea1af245e23ad
+SHA512:
+  metadata.gz: fc3cac76f70d43922c65dac966120e095b198040cd5902f6c60a2329c2efc74a49aba372ccf2f0e1dc6e90eb869771585d6542e57e8b8fbec88ac112a2768997
+  data.tar.gz: 2e4089710844a5774c5b9c9ffc892c0cdfb347bf791bd4aa3418985f283623a6dae61cd883671b38a942691e1d8e1f3b8b58ea939b29c1dc1b6bfc4ab1845254

data/LICENSE

@@ -0,0 +1,8 @@
+The Open Government Licence (OGL) Version 3
+
+Copyright (c) 2026 Environment Agency
+
+This source code is licensed under the Open Government Licence v3.0. To view this
+licence, visit www.nationalarchives.gov.uk/doc/open-government-licence/version/3
+or write to the Information Policy Team, The National Archives, Kew, Richmond,
+Surrey, TW9 4DU.

data/README.md

@@ -0,0 +1,204 @@
+# DefraRubyMap
+
+[![Quality gate status](https://sonarcloud.io/api/project_badges/measure?project=DEFRA_defra-ruby-map&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=DEFRA_defra-ruby-map)
+
+Rails engine gem providing the [DEFRA Interactive Map](https://defra.github.io/interactive-map/) component for GOV.UK services, with OS grid reference conversion, bidirectional field sync, and a server-side proxy that keeps the OS API key out of the browser.
+
+## Contents
+
+- [@defra/interactive-map](https://github.com/DEFRA/interactive-map) — UMD build with the MapLibre provider and the interact, search, map-styles and scale-bar plugins
+- [proj4js](https://github.com/proj4js/proj4js) — WGS84/OSGB36 coordinate conversion
+- OS grid reference converter, ported from the [os_map_ref](https://github.com/DEFRA/os-map-ref) gem
+- Ordnance Survey Vector Tile stylesheets (Outdoor / Dark / Black & White), vendored and pinned
+- A generic map initializer with bidirectional grid reference sync
+- A server-side proxy for the OS Places and OS Vector Tile APIs
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "defra_ruby_map"
+```
+
+## Configuration
+
+Configure the OS Data Hub API key in an initializer. A single key is used for all three OS endpoints:
+
+- `https://api.os.uk/maps/vector/v1` — vector tiles, glyphs and TileJSON
+- `https://api.os.uk/search/places/v1/find` — address search
+- `https://api.os.uk/search/places/v1/nearest` — nearest-address lookup
+
+```ruby
+# config/initializers/defra_ruby_map.rb
+DefraRubyMap.configure do |config|
+  config.os_maps_api_key = ENV.fetch("OS_MAPS_API_KEY", nil)
+end
+```
+
+Mount the engine to expose the proxy endpoints. Mounting at `/defra-ruby-map` keeps the proxy URLs aligned with the asset URLs (see [How assets are served](#how-assets-are-served)):
+
+```ruby
+# config/routes.rb
+mount DefraRubyMap::Engine => "/defra-ruby-map"
+```
+
+No asset precompilation or copy step is required — the engine serves its vendored assets automatically (see below).
+
+## Usage
+
+Add a map container to your view. `map_init.js` reads its configuration from `data-` attributes:
+
+```erb
+<div id="my-map"
+     class="govuk-!-display-none"
+     data-module="defra-interactive-map"
+     data-proxy-url="/defra-ruby-map"
+     data-images-url="<%= defra_map_asset_path("images") %>"
+     data-initial-grid-reference="<%= @form.grid_reference %>"
+     data-center="-1.5,52.5"
+     data-zoom="6">
+</div>
+```
+
+Load the assets. Reference the **vendored bundles, CSS and images** with the `defra_map_asset_path` helper (they are served by the engine, not the asset pipeline), and the **first-party JS** (`grid_reference_converter`, `grid_ref_sync`, `map_init`) with `javascript_include_tag` (these go through Sprockets and are precompiled; load `map_init` last):
+
+```erb
+<link rel="stylesheet" href="<%= defra_map_asset_path("css/interactive-map.css") %>" media="all" />
+<link rel="stylesheet" href="<%= defra_map_asset_path("css/search-plugin.css") %>" media="all" />
+<link rel="stylesheet" href="<%= defra_map_asset_path("css/map-styles-plugin.css") %>" media="all" />
+<link rel="stylesheet" href="<%= defra_map_asset_path("css/scale-bar-plugin.css") %>" media="all" />
+
+<script src="<%= defra_map_asset_path("proj4js/proj4.js") %>"></script>
+<script src="<%= defra_map_asset_path("defra-interactive-map/index.js") %>"></script>
+<script src="<%= defra_map_asset_path("maplibre-provider/index.js") %>"></script>
+<script src="<%= defra_map_asset_path("interact-plugin/index.js") %>"></script>
+<script src="<%= defra_map_asset_path("search-plugin/index.js") %>"></script>
+<script src="<%= defra_map_asset_path("map-styles-plugin/index.js") %>"></script>
+<script src="<%= defra_map_asset_path("scale-bar-plugin/index.js") %>"></script>
+
+<%= javascript_include_tag "defra-ruby-map/grid_reference_converter" %>
+<%= javascript_include_tag "defra-ruby-map/grid_ref_sync" %>
+<%= javascript_include_tag "defra-ruby-map/map_init" %>
+```
+
+> Do not load the vendored bundles with `javascript_include_tag`/`stylesheet_link_tag` — they are not on the Sprockets precompile list and would raise `AssetNotPrecompiled` in production.
+
+Initialize the map from your application JS:
+
+```javascript
+DefraMap.init(document.getElementById("my-map"), {
+  mapLabel: "Select waste activity location",
+  gridRefFieldId: "my-grid-reference-field"  // optional, enables bidirectional sync
+});
+```
+
+## How assets are served
+
+The engine mounts a Rack middleware (`DefraRubyMap::AssetServer`) that serves the vendored JS, CSS and images straight from the gem at `/defra-ruby-map/<gem-version>/…`, with `Cache-Control: public, max-age=31536000, immutable`. Nothing is copied into the host app's `public/` directory, so the mechanism is safe on read-only filesystems and during rolling deploys, and each running process serves the assets for its own gem version.
+
+`defra_map_asset_path("search-plugin/index.js")` returns `/defra-ruby-map/<gem-version>/search-plugin/index.js`. The version segment makes each release's URLs unique, so the immutable caching is safe.
+
+## JavaScript API
+
+### `DefraMap.init(container, options)`
+
+Initializes the interactive map on the given container element and returns the map instance (or `null` if the bundles failed to load).
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `mapLabel` | string | Accessible label for the map (default: `"Interactive map"`) |
+| `gridRefFieldId` | string | ID of a grid reference input field for bidirectional sync (optional) |
+| `onError` | function | Called with the error if initialization fails, e.g. for monitoring (optional) |
+
+The container reads further configuration from `data-` attributes:
+
+| Attribute | Description |
+|-----------|-------------|
+| `data-proxy-url` | Base URL of the engine's proxy endpoints (e.g. `/defra-ruby-map`). Required for address search, OS tiles and the default OS basemap. |
+| `data-images-url` | Base URL of the vendored images (use `defra_map_asset_path("images")`). Also used to locate the vendored OS style JSONs. |
+| `data-initial-grid-reference` | Pre-centre the map on this grid reference |
+| `data-center` | Default centre as `lng,lat` (default: `-1.5,52.5`) |
+| `data-zoom` | Default zoom level (default: `6`) |
+
+When `data-proxy-url` and `data-images-url` are both present, the map defaults to the proxied OS Outdoor basemap; otherwise it falls back to an OpenStreetMap style.
+
+### Proxy endpoints
+
+The engine provides three server-side proxy endpoints (relative to the mount point) that inject the OS API key. The key is never exposed to the browser.
+
+| Endpoint | Purpose |
+|----------|---------|
+| `GET geocode-proxy?query=Bristol` | Address search via the OS Places API |
+| `GET nearest-proxy?easting=530070&northing=180358` | Nearest-address lookup for a clicked location |
+| `GET os-tiles-proxy/*path` | OS Vector Tile API (tiles, glyphs, TileJSON), restricted to `maps/vector/v1/vts` paths |
+
+### `DefraGridRef`
+
+Grid reference conversion utilities (WGS84 ↔ OSGB36 ↔ OS grid reference). Grid references must be two letters plus ten digits:
+
+```javascript
+DefraGridRef.coordsToGridRef(lng, lat)                  // => "ST 58132 72695" or null
+DefraGridRef.gridRefToCoords("ST 58132 72695")          // => [lng, lat] or null
+DefraGridRef.isValidGridRef("ST 58132 72695")           // => true
+DefraGridRef.eastingNorthingToGridRef(358132, 172695)   // => "ST 58132 72695" or null
+DefraGridRef.gridRefToEastingNorthing("ST 58132 72695") // => [easting, northing] or null
+DefraGridRef.coordsToEastingNorthing(lng, lat)          // => [easting, northing] or null
+```
+
+## Content Security Policy
+
+With the default OS basemap, all map data — tiles, glyphs, TileJSON, style JSONs, sprites and address search — is served same-origin (via the engine's proxy or the asset middleware), so no external hosts need allowlisting. MapLibre GL itself needs:
+
+| Directive | Value | Reason |
+|-----------|-------|--------|
+| `script-src` / `worker-src` | `blob:` | MapLibre GL web workers |
+| `img-src` | `data:` `blob:` | MapLibre marker/canvas internals |
+
+If you disable the proxy and fall back to the OpenStreetMap basemap, also allowlist `https://tiles.openfreemap.org` under `connect-src`.
+
+## Rate limiting
+
+The proxy endpoints are unauthenticated by design — they serve a public page — and each request spends the OS API quota. 
+
+Apply **per-IP rate limiting** at the host or WAF/CDN layer. A ready-to-tune [Rack::Attack](https://github.com/rack/rack-attack) config:
+
+```ruby
+# config/initializers/rack_attack.rb
+class Rack::Attack
+  # Address search / reverse lookup — user-driven, low volume.
+  throttle("defra_ruby_map/places", limit: 60, period: 1.minute) do |req|
+    req.ip if req.path.end_with?("/geocode-proxy", "/nearest-proxy")
+  end
+
+  # Vector tiles — many requests per map view, but cacheable; throttle generously.
+  throttle("defra_ruby_map/tiles", limit: 600, period: 1.minute) do |req|
+    req.ip if req.path.include?("/os-tiles-proxy/")
+  end
+end
+```
+
+## Updating vendored assets
+
+Third-party JS/CSS and the pinned OS stylesheets are managed via npm:
+
+```bash
+npm install          # first time
+npm update           # update @defra/interactive-map and proj4
+npm run vendor       # copy the UMD bundles, CSS, images and pinned OS styles into vendor/assets/
+```
+
+The `vendor/assets/` files are committed to git so the gem works without npm at install time. CI re-runs `npm run vendor` and fails if the committed output drifts from the locked package versions. The `app/assets/` files are first-party code and are not touched by `npm run vendor`.
+
+## Testing
+
+```bash
+bundle exec rspec                              # Ruby: engine, proxy and asset middleware
+npm test                                       # JS: converter, search parsing and map/field sync
+npm run test:coverage                          # JS tests plus lcov coverage report for SonarCloud
+bundle exec rubocop                            # lint
+```
+
+## License
+
+Licensed under the [Open Government Licence v3.0](LICENSE) (`OGL-UK-3.0`).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/app/assets/javascripts/defra-ruby-map/grid_ref_sync.js

@@ -0,0 +1,143 @@
+// DefraGridRefSync — bidirectional sync between a DefraMap instance and a
+// grid reference input field. Depends on DefraGridRef (loaded per-page via
+// its own script tag) for coordinate conversions. Include this file before
+// map_init.js.
+
+(function () {
+  "use strict";
+
+  const GRIDREF_MARKER_ID = "grid-ref-pin";
+  const SEARCH_MARKER_ID = "search";
+  const INTERACT_MARKER_ID = "location";
+  const PROXY_TIMEOUT_MS = 2000;
+
+  // Visually-hidden aria-live region so a screen-reader user hears when the map
+  // updates the grid reference field. Inline styles avoid depending on host CSS.
+  function createLiveRegion() {
+    const region = document.createElement("div");
+    region.setAttribute("role", "status");
+    region.setAttribute("aria-live", "polite");
+    region.style.cssText = "position:absolute;width:1px;height:1px;margin:-1px;padding:0;" +
+      "overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0;";
+    return region;
+  }
+
+  // Extracts the nearest address's grid reference from a proxy response, or
+  // null when the response has no usable result.
+  function nearestGridRefFrom(data) {
+    const first = data?.results?.[0];
+    const record = first ? first.DPA || first.LPI : null;
+    if (!record?.X_COORDINATE || !record?.Y_COORDINATE) { return null; }
+    return window.DefraGridRef.eastingNorthingToGridRef(record.X_COORDINATE, record.Y_COORDINATE);
+  }
+
+  // Nearest address lookup via the proxy, falling back to the raw grid
+  // reference on timeout, error, or an empty result. `state.pendingController`
+  // is shared with the caller so a newer lookup aborts an in-flight one.
+  function lookupNearestGridRef(proxyUrl, en, rawGridRef, state, setField) {
+    if (state.pendingController) { state.pendingController.abort(); }
+    const controller = new AbortController();
+    state.pendingController = controller;
+    const timeoutId = setTimeout(function () {
+      if (controller.signal.aborted) { return; }
+      controller.abort();
+      setField(rawGridRef);
+    }, PROXY_TIMEOUT_MS);
+
+    fetch(`${proxyUrl}/nearest-proxy?easting=${Math.round(en[0])}&northing=${Math.round(en[1])}`, { signal: controller.signal })
+      .then(function (response) { return response.json(); })
+      .then(function (data) {
+        clearTimeout(timeoutId);
+        // Only clear the shared controller if it is still ours; a newer
+        // request may have replaced it, and nulling it would break the
+        // abort chain and let this stale response overwrite the field.
+        if (state.pendingController === controller) { state.pendingController = null; }
+        if (controller.signal.aborted) { return; }
+        setField(nearestGridRefFrom(data) || rawGridRef);
+      })
+      .catch(function () {
+        clearTimeout(timeoutId);
+        if (state.pendingController === controller) { state.pendingController = null; }
+        if (!controller.signal.aborted) { setField(rawGridRef); }
+      });
+  }
+
+  // gridRefZoom: zoom level for flying to a typed grid reference (the caller,
+  // map_init.js, owns the constant).
+  function wireGridRefSync(interactiveMap, field, proxyUrl, gridRefZoom) {
+    let mapInstance = null;
+    const state = { pendingController: null };
+
+    const liveRegion = createLiveRegion();
+    (field.parentNode || document.body).appendChild(liveRegion);
+
+    // Writes a map-derived value into the field, tells host JS (validation,
+    // character count) via a "change" event, and announces it to assistive tech.
+    // A "change" event — not "input" — avoids re-triggering the field→map handler.
+    function setField(value) {
+      field.value = value;
+      field.dispatchEvent(new Event("change", { bubbles: true }));
+      liveRegion.textContent = "Grid reference updated to " + value;
+    }
+
+    // Map → field: nearest address lookup via proxy
+    interactiveMap.on("interact:markerchange", function (event) {
+      if (!event?.coords) { return; }
+      interactiveMap.removeMarker(GRIDREF_MARKER_ID);
+      interactiveMap.removeMarker(SEARCH_MARKER_ID);
+
+      const en = window.DefraGridRef.coordsToEastingNorthing(event.coords[0], event.coords[1]);
+      if (!en) { return; }
+      const rawGridRef = window.DefraGridRef.eastingNorthingToGridRef(en[0], en[1]);
+      if (!rawGridRef) { return; }
+
+      if (proxyUrl) {
+        lookupNearestGridRef(proxyUrl, en, rawGridRef, state, setField);
+      } else {
+        setField(rawGridRef);
+      }
+    });
+
+    // Search result selected: the plugin places its own "search" marker, so
+    // clear the map-click / typed markers and set the field to its location.
+    interactiveMap.on("search:match", function (event) {
+      if (!event?.point) { return; }
+      interactiveMap.removeMarker(GRIDREF_MARKER_ID);
+      interactiveMap.removeMarker(INTERACT_MARKER_ID);
+      const gridRef = window.DefraGridRef.coordsToGridRef(event.point[0], event.point[1]);
+      if (gridRef) { setField(gridRef); }
+    });
+
+    // Capture underlying MapLibre instance for flyTo
+    interactiveMap.on("map:ready", function (event) {
+      if (event?.map) { mapInstance = event.map; }
+    });
+
+    // Pin the field's pre-filled grid reference. "map:firstidle" is the
+    // earliest event at which markers project correctly — any sooner and the
+    // pin lands at pixel (0,0).
+    interactiveMap.on("map:firstidle", function () {
+      const value = field.value;
+      if (!window.DefraGridRef.isValidGridRef(value)) { return; }
+      const coords = window.DefraGridRef.gridRefToCoords(value);
+      if (coords) { interactiveMap.addMarker(GRIDREF_MARKER_ID, coords); }
+    });
+
+    field.addEventListener("input", function () {
+      if (!mapInstance) { return; }
+      const value = field.value;
+      if (!window.DefraGridRef.isValidGridRef(value)) { return; }
+      const coords = window.DefraGridRef.gridRefToCoords(value);
+      if (!coords) { return; }
+      interactiveMap.removeMarker(GRIDREF_MARKER_ID);
+      interactiveMap.removeMarker(SEARCH_MARKER_ID);
+      interactiveMap.removeMarker(INTERACT_MARKER_ID);
+      interactiveMap.addMarker(GRIDREF_MARKER_ID, coords);
+      mapInstance.flyTo({ center: coords, zoom: gridRefZoom });
+    });
+  }
+
+  window.DefraGridRefSync = {
+    wire: wireGridRefSync
+  };
+})();

data/app/assets/javascripts/defra-ruby-map/grid_reference_converter.js

@@ -0,0 +1,123 @@
+// Grid Reference Converter
+// Converts between WGS84 (lng/lat), OSGB36 (easting/northing), and OS grid references.
+// Ported from the os_map_ref Ruby gem (https://github.com/DEFRA/os-map-ref).
+//
+// Dependencies: proj4 (loaded globally as window.proj4)
+
+(function () {
+  "use strict";
+
+  // OSGB36 / British National Grid projection (EPSG:27700)
+  const OSGB36 = "+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 " +
+    "+x_0=400000 +y_0=-100000 +ellps=airy " +
+    "+towgs84=446.448,-125.157,542.06,0.15,0.247,0.842,-20.489 +units=m +no_defs +type=crs";
+
+  // Grid of 100km squares as arranged over the UK.
+  // Origin (0,0) is bottom-left corner (SV). Rows go south-to-north.
+  // Matches the os_map_ref gem grid (reversed).
+  const GRID = [
+    ["SV", "SW", "SX", "SY", "SZ", "TV", "TW", "TX", "TY", "TZ"],
+    ["SQ", "SR", "SS", "ST", "SU", "TQ", "TR", "TS", "TT", "TU"],
+    ["SL", "SM", "SN", "SO", "SP", "TL", "TM", "TN", "TO", "TP"],
+    ["SF", "SG", "SH", "SJ", "SK", "TF", "TG", "TH", "TJ", "TK"],
+    ["SA", "SB", "SC", "SD", "SE", "TA", "TB", "TC", "TD", "TE"],
+    ["NV", "NW", "NX", "NY", "NZ", "OV", "OW", "OX", "OY", "OZ"],
+    ["NQ", "NR", "NS", "NT", "NU", "OQ", "OR", "OS", "OT", "OU"],
+    ["NL", "NM", "NN", "NO", "NP", "OL", "OM", "ON", "OO", "OP"],
+    ["NF", "NG", "NH", "NJ", "NK", "OF", "OG", "OH", "OJ", "OK"],
+    ["NA", "NB", "NC", "ND", "NE", "OA", "OB", "OC", "OD", "OE"],
+    ["HV", "HW", "HX", "HY", "HZ", "JV", "JW", "JX", "JY", "JZ"],
+    ["HQ", "HR", "HS", "HT", "HU", "JQ", "JR", "JS", "JT", "JU"],
+    ["HL", "HM", "HN", "HO", "HP", "JL", "JM", "JN", "JO", "JP"]
+  ];
+
+  // The caps mirror GRID's extent: 10 x 13 hundred-km squares.
+  const MAX_EASTING = 1000000;
+  const MAX_NORTHING = 1300000;
+
+  // A grid reference is a two-letter square prefix plus five digits per axis.
+  const PREFIX_LENGTH = 2;
+  const COORD_DIGITS = 5;
+  const EASTING_END = PREFIX_LENGTH + COORD_DIGITS;
+  const NORTHING_END = EASTING_END + COORD_DIGITS;
+
+  // Build reverse lookup: prefix -> [rowIndex, colIndex]
+  const PREFIX_LOOKUP = {};
+  for (let row = 0; row < GRID.length; row++) {
+    for (let col = 0; col < GRID[row].length; col++) {
+      PREFIX_LOOKUP[GRID[row][col]] = [row, col];
+    }
+  }
+
+  function padCoord(value) {
+    return String(value % 100000).padStart(COORD_DIGITS, "0");
+  }
+
+  function eastingNorthingToGridRef(easting, northing) {
+    easting = Math.round(easting);
+    northing = Math.round(northing);
+
+    if (!Number.isFinite(easting) || !Number.isFinite(northing)) { return null; }
+    if (easting < 0 || northing < 0 || easting >= MAX_EASTING || northing >= MAX_NORTHING) {
+      return null;
+    }
+
+    const gridEasting = Math.floor(easting / 100000);
+    const gridNorthing = Math.floor(northing / 100000);
+
+    const prefix = GRID[gridNorthing][gridEasting];
+
+    return `${prefix} ${padCoord(easting)} ${padCoord(northing)}`;
+  }
+
+  function gridRefToEastingNorthing(gridRef) {
+    if (!gridRef || typeof gridRef !== "string") { return null; }
+
+    // Normalise to two letters + ten digits, accepting exactly what
+    // isValidGridRef accepts regardless of whitespace grouping. Refs with
+    // fewer digits are rejected rather than mis-scaled to a wrong location.
+    const cleaned = gridRef.replace(/\s+/g, "").toUpperCase();
+    if (!/^[A-Z]{2}\d{10}$/.test(cleaned)) { return null; }
+
+    const coords = PREFIX_LOOKUP[cleaned.substring(0, PREFIX_LENGTH)];
+    if (!coords) { return null; }
+
+    const easting = coords[1] * 100000 + Number.parseInt(cleaned.substring(PREFIX_LENGTH, EASTING_END), 10);
+    const northing = coords[0] * 100000 + Number.parseInt(cleaned.substring(EASTING_END, NORTHING_END), 10);
+
+    return [easting, northing];
+  }
+
+  function coordsToEastingNorthing(lng, lat) {
+    if (typeof proj4 === "undefined") { return null; }
+    return proj4("EPSG:4326", OSGB36, [lng, lat]);
+  }
+
+  function coordsToGridRef(lng, lat) {
+    const en = coordsToEastingNorthing(lng, lat);
+    if (!en) { return null; }
+    return eastingNorthingToGridRef(en[0], en[1]);
+  }
+
+  function gridRefToCoords(gridRef) {
+    if (typeof proj4 === "undefined") { return null; }
+    const en = gridRefToEastingNorthing(gridRef);
+    if (!en) { return null; }
+    return proj4(OSGB36, "EPSG:4326", en);
+  }
+
+  function isValidGridRef(str) {
+    if (!str || typeof str !== "string") { return false; }
+    const cleaned = str.replace(/\s+/g, "").toUpperCase();
+    return /^[A-Z]{2}\d{10}$/.test(cleaned) && !!PREFIX_LOOKUP[cleaned.substring(0, PREFIX_LENGTH)];
+  }
+
+  window.DefraGridRef = {
+    coordsToGridRef: coordsToGridRef,
+    gridRefToCoords: gridRefToCoords,
+    isValidGridRef: isValidGridRef,
+    eastingNorthingToGridRef: eastingNorthingToGridRef,
+    gridRefToEastingNorthing: gridRefToEastingNorthing,
+    coordsToEastingNorthing: coordsToEastingNorthing
+  };
+})();