@superrouteca/smap 1.0.6 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 1.1.1 — 2026-10-27
+
+- deck.gl's interleaved overlay works on the map again: `addDeckLayer` and `deckOverlay` with deck.gl 9.x no longer
+  fail on every frame ("Cannot read properties of undefined (reading 'height')"). The map engine now answers the
+  camera where deck.gl reads it; an engine that already does so is left as it is.
+
+## 1.1.0 — 2026-10-27
+
+- Style layers: sources and layers of the Style Specification v8 are added as they are (`addSource`, `addStyleLayer`,
+  `setPaint`, `setLayout`, `setFilter`, `getStyleLayer`, `removeSource`), so layers copied from Mapbox Studio,
+  Maputnik or another map page work unchanged, and they are kept when the scheme or the language changes.
+- Slots: a layer can be drawn over land and water (`bottom`), under the roads (`roads`), under the labels (`labels`)
+  or on top (`top`), or under a layer you name (`before`). The slots stay in place when the basemap changes. A layer
+  without a slot draws on top as before.
+- Basemap options: `setBasemap` shows, hides and recolours water, land, parks, roads (by level), rail, buildings,
+  boundaries, points of interest and labels, and changes road widths; kept when the scheme or the language changes.
+- Saved custom styles: `style: 'custom:<id>'` shows a style saved in the developer center, in every label language.
+- Files: `addData` reads KML, KMZ, GPX, encoded polylines, WKT, WKB, CSV, TopoJSON and GeoJSON on the device and
+  draws their points, lines and areas, with the colours a file gives (KML styles and simplestyle properties) and a
+  popup of each feature's name and description. `toGeoJSON` and `toKML` write a layer out; `formats.read` reads a
+  file without a map; `convert` has sMap convert large files.
+- External layers: raster tiles and TileJSON, OGC WMS and WMTS, vector tiles and PMTiles archives from any address,
+  and ArcGIS REST tile and vector tile services, each with its attribution beside the map's credit.
+- `toJSON` and `loadLayers` save a map's basemap, sources and layers as one JSON document that every sMap SDK opens.
+- deck.gl layers are drawn among the map's own layers (`addDeckLayer`, `removeDeckLayer`) when deck.gl is loaded.
+- `rasterUrl` gives sMap's raster tiles of a scheme or custom style for tools without vector tiles; `map.rasterUrl`
+  gives them on the map's own node and key, in its style and language.
+- `map.deckOverlay(props)` gives the map's deck.gl overlay and sets its other deck.gl props (tooltips, clicks).
+- The JS client's `demote(url)` moves a node that did not answer to the end of the list, so tools that read tiles
+  themselves follow the same node order; `apiKey` and `renewsToken` read how the client was set up.
+
 ## 1.0.6 — 2026-10-27
 
 - Close up (from zoom 13, `bakeZoom`) each pin's number is drawn into the pin, so where pins overlap the pin on top covers the one below completely.

package/README.md

@@ -7,10 +7,11 @@
 
 Maps from Superroute's sMap service for the web: five colour schemes, labels in any language, your points, lines and
 areas drawn on the GPU (hundreds of thousands of points, clustered or not), 3D buildings and areas, and tokens that
-renew themselves. Also the JS client (no map view) for servers and workers: tokens, the nearest node, styles, tiles
+renew themselves; standard style layers, basemap options, KML / GPX / CSV and other files, WMS, WMTS, PMTiles and
+ArcGIS layers, deck.gl layers, and maps saved as JSON. Also the JS client (no map view) for servers and workers: tokens, the nearest node, styles, tiles
 and raw reads.
 
-- Version 1.0.6, MIT licence (see `LICENSE` at the repository root)
+- Version 1.1.0, MIT licence (see `LICENSE` at the repository root)
 - Works with bundlers (Vite, webpack, Next.js and others): ES module and CommonJS entry points with types
 - Nothing else to install: the map renderer is bundled in the package
 - Importing is safe on a server; a map is created in the browser only
@@ -200,6 +201,173 @@ map.addPoints('stops', stops, {           // {lng, lat, stop_number, status_colo
 Numbers and badges are drawn over all pins of the layer, so where pins overlap a lower pin's number can show through
 an upper pin.
 
+## Style layers and sources
+
+Sources and layers of the Style Specification v8 are passed to the map as they are, so a layer copied from Mapbox
+Studio, Maputnik or another map page works unchanged. They are kept when the scheme or the language changes.
+
+```js
+map.addSource('parcels', { type: 'vector', tiles: ['https://tiles.example/{z}/{x}/{y}.pbf'], attribution: '© Example' });
+map.addStyleLayer({ id: 'parcel-lines', type: 'line', source: 'parcels', 'source-layer': 'parcels',
+  paint: { 'line-color': '#64748b' } }, { slot: 'roads' });
+map.setPaint('parcel-lines', 'line-width', 2);
+map.setLayout('parcel-lines', 'visibility', 'none');
+map.setFilter('parcel-lines', ['==', ['get', 'zoning'], 'R1']);
+map.getStyleLayer('parcel-lines');   // the layer as a Style Specification object
+map.removeSource('parcels');         // with the layers that read it
+```
+
+`setPaint`, `setLayout` and `setFilter` also work on the basemap's own layers. `removeLayer(id)` removes a layer of
+any kind.
+
+## Slots
+
+A layer is placed relative to the basemap by a slot, or under a layer you name. A layer without either draws as in
+1.0: on top, in the order added.
+
+| Slot | Where |
+|---|---|
+| `bottom` | over land and water, under everything else |
+| `roads` | under the roads |
+| `labels` | under the labels |
+| `top` | on top |
+
+```js
+map.addPolygons('zones', zones, { slot: 'bottom' });
+map.addLines('routes', routes, { slot: 'labels' });           // road names stay readable over the routes
+map.addStyleLayer(layer, { before: 'routes' });              // under one of your layers, or a basemap layer
+```
+
+The slots are found from the basemap's classes, so they stay in place when the basemap changes. `map.slots()` gives
+the layer each slot begins at. `zIndex` orders layers inside one slot.
+
+## Basemap options
+
+`setBasemap` shows, hides and recolours the basemap by class. The classes are `land`, `landcover`, `parks`, `landuse`,
+`airports`, `water`, `roads` (and `roads.highway`, `roads.major`, `roads.minor`, `roads.paths`), `rail`, `buildings`,
+`boundaries`, `labels` (and `labels.places`, `labels.roads`, `labels.water`, `labels.addresses`) and `pois`.
+
+```js
+map.setBasemap({
+  water: { color: '#9cc0e6' },
+  roads: { color: '#ffffff', width: 1.2 },     // every roads.* class
+  'roads.highway': { color: '#f6c26b' },        // the class itself wins over roads
+  pois: { visible: false },
+  labels: { halo: '#ffffff' },
+});
+map.basemap();          // the overrides in force
+map.setBasemap({});     // back to the scheme
+```
+
+| Field | Meaning |
+|---|---|
+| `visible` | show or hide |
+| `color` | fill, line or background colour; the text colour for labels |
+| `casing` | the casing colour of roads |
+| `halo` | the halo colour of labels |
+| `opacity` | 0 to 1 |
+| `width` | a line width factor, 0.25 to 4, of the scheme's own width |
+
+Each call replaces the overrides set before. They are kept when the scheme or the language changes. An unknown class
+or field throws an error that names it. `applyBasemapOverrides(style, overrides)` applies the same rules to a style
+document (for example on a server).
+
+**Saved custom styles.** A style saved in the Superroute developer center is used by its id:
+`new Map({ style: 'custom:sms_…' })` or `map.setStyle('custom:sms_…')`. It is served in every label language, with
+your key or token, like the five schemes.
+
+## Files: KML, GPX, CSV and more
+
+`addData` reads a file on the device and draws it: points as the layer `<id>`, lines as `<id>:lines`, areas as
+`<id>:areas`.
+
+```js
+await map.addData('trip', file);                              // a File from an <input type="file">
+await map.addData('stores', csvText, { format: 'csv', lat: 'Latitude', lng: 'Longitude', slot: 'top' });
+await map.addData('route', '_p~iF~ps|U_ulLnnqC', { format: 'polyline', width: 5 });
+map.toGeoJSON('trip');      // the features as GeoJSON
+map.toKML('trip');          // the features as a KML document
+map.removeLayer('trip');    // all three layers
+```
+
+| Format | Reads |
+|---|---|
+| `kml`, `kmz` | Google Earth and My Maps files: placemarks, extended data, styles as simplestyle colours, tracks |
+| `gpx` | waypoints, routes, tracks (with elevation) |
+| `polyline`, `polyline6` | encoded polylines, precision 5 (Google, OSRM) and 6 (Valhalla) |
+| `wkt`, `wkb` | Well-Known Text and Binary (also EWKB and hexadecimal text) |
+| `csv` | latitude and longitude columns, named or found from common headings |
+| `topojson`, `geojson` | TopoJSON topologies, GeoJSON (RFC 7946) |
+
+The format comes from the file name or the content when not given (polylines are always named). A layer with no
+colour of its own draws the simplestyle properties of its features (`marker-color`, `marker-size`, `stroke`,
+`stroke-width`, `stroke-opacity`, `fill`, `fill-opacity`), so files from geojson.io, GitHub or Mapbox look as they do
+there. A click opens a popup with the feature's title (or name) and description, unless `popup` is given.
+
+`formats.read(input, { format, lat, lng })` gives the FeatureCollection without a map. `convert(file, { format })`
+(and `map.convert`) has sMap convert a file instead: for large files (up to 20 MB). The answer is the same.
+
+## External layers
+
+The attribution of each source is shown beside the map's credit. Google and Bing tiles are refused, as their licences
+do not allow them.
+
+```js
+map.addRasterLayer('osm', { tiles: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png', attribution: '© OpenStreetMap', opacity: 0.6 });
+map.addRasterLayer('imagery', { url: 'https://tiles.example/imagery.json' });                  // TileJSON
+map.addWmsLayer('flood', { url: 'https://wms.example/ows', layers: 'flood_zones', slot: 'labels' });
+await map.addWmtsLayer('ortho', { url: 'https://wmts.example/WMTSCapabilities.xml', layer: 'ortho' });
+map.addVectorTiles('parcels', { pmtiles: 'https://data.example/parcels.pmtiles',
+  layers: [{ id: 'parcel-fill', type: 'fill', 'source-layer': 'parcels', paint: { 'fill-color': '#fde68a' } }] });
+await map.addArcGisLayer('esri', { url: 'https://services.example/arcgis/rest/services/World/MapServer' });
+```
+
+- `addRasterLayer`: XYZ templates (`tiles`) or a TileJSON address (`url`); `tileSize`, `opacity`, `minzoom`, `maxzoom`.
+- `addWmsLayer`: OGC WMS 1.3.0 (or 1.1.1), one GetMap per tile in Web Mercator; `layers`, `styles`, `format`,
+  `transparent`, `params`.
+- `addWmtsLayer`: OGC WMTS from the GetCapabilities address (KVP or REST, Web Mercator matrix sets), or a REST
+  template with `{TileMatrix}`, `{TileRow}` and `{TileCol}`. Returns a promise.
+- `addVectorTiles`: Mapbox Vector Tiles from templates (`tiles`), a TileJSON address (`url`) or a PMTiles archive
+  (`pmtiles`, or a `url` ending in `.pmtiles`), drawn by your style layers.
+- `addArcGisLayer`: an ArcGIS REST MapServer / ImageServer (raster tiles) or VectorTileServer (drawn by `layers`, or
+  by the service's own style); the service's copyright text is its attribution. Returns a promise.
+
+Every external layer takes `slot`, `before` and `zIndex`. `rasterUrl(style, { lang, retina })` gives sMap's own
+raster tiles as an XYZ template (`rasterTileJsonUrl` their TileJSON), for tools without vector tiles such as QGIS;
+`map.rasterUrl(style?, { lang, retina })` gives them on the map's own node and key, in its style and language.
+
+## A map as JSON
+
+`map.toJSON()` writes the map's basemap (scheme, language, overrides), sources and layers as one JSON document, and
+`map.loadLayers(json)` loads it, on the web and in every other sMap SDK. A map built on a page opens the same in an
+app. The shape is described in `shared/LAYER-JSON.md` of the repository, with a JSON Schema. Popups are written as
+templates (`popup: '<b>{name}</b>'`); popup functions, click handlers and deck.gl layers are code and are not
+written.
+
+## deck.gl layers
+
+deck.gl layers are drawn among the map's own layers, under the labels if you like, through deck.gl's map overlay.
+deck.gl is optional and loaded only by you (deck.gl 9; `@deck.gl/mapbox` and the layer packages you use):
+
+```js
+import { useDeck } from '@superrouteca/smap';
+import * as deckMapbox from '@deck.gl/mapbox';
+import { ArcLayer } from '@deck.gl/layers';
+
+useDeck(deckMapbox);
+map.addDeckLayer(new ArcLayer({ id: 'flows', data, getSourcePosition: (d) => d.from, getTargetPosition: (d) => d.to }), { slot: 'labels' });
+map.removeDeckLayer('flows');
+```
+
+On a page without a bundler, the script build of deck.gl (its global `deck`) is used without `useDeck`.
+
+`map.deckOverlay(props)` gives the map's deck.gl overlay (made on first use) and sets its other deck.gl props, such as
+tooltips and clicks; its layers stay the ones added with `addDeckLayer`:
+
+```js
+map.deckOverlay({ getTooltip: ({ object }) => object && object.name });
+```
+
 ## Map keys and tokens
 
 - **Map key** (`apiKey: 'smk_…'`): created in the Superroute developer center, with the sites (and apps) it may be
@@ -224,6 +392,10 @@ const tile = await client.tile('basemap', 12, 1143, 1493);   // Uint8Array, or n
 
 Runs wherever `fetch` exists (browsers, Node.js 18+, workers); elsewhere pass `fetch` in the options.
 
+`client.nodes()` lists the nodes nearest first; `client.demote(url)` moves a node that did not answer to the end, so a
+tool that reads tiles itself follows the same order as the client. `client.apiKey` and `client.renewsToken` (a
+`getToken` was given) say how the client was set up.
+
 ## Data attribution
 
 The map data credit stays visible on every map, as the data licence requires. Every map shows a small sMap badge in
@@ -231,7 +403,8 @@ its bottom-right corner, left of the attribution (above it when the map is too n
 
 ## Where the code comes from
 
-The sources are in `src/` (the Web SDK `smap.js` and `smap.css`, the JS client `smap-client.js` and its types).
+The sources are in `src/` (the Web SDK `smap.js` and `smap.css`, the parts that need no map `smap-interop.js`:
+formats, basemap options, slots, URLs, PMTiles; the JS client `smap-client.js` and its types).
 `npm run build` writes `dist/` from them and the rendering engine (an exact devDependency); `dist/SOURCE.json`
 records the version, the engine and the hash of every file. `dist/` is committed and never edited by hand. The type
 declarations of the map SDK are in `types/`.

package/dist/SOURCE.json

@@ -1,17 +1,17 @@
 {
-  "sdkVersion": "1.0.6",
+  "sdkVersion": "1.1.1",
   "engine": "maplibre-gl 6.16.0",
   "files": {
-    "smap.js": "ebb6560db4ed5564693ebbf19b030bba0d5bbcc3fee2f7e2b5bf959584ffba18",
+    "smap.js": "1967bba886c34ba175e7d98213bb4a5ac0f239392b3883932e39e0e47ddcf3fe",
     "smap.css": "5e3bdcb00b8fc8805f545b76cdeea5e783c89984f48ec2fee66c4319af4ada0b",
-    "smap-client.js": "87d4eaad1204383570d6d3655b52a45f19e6698b8fdbaa42c82a03471cba2e3d",
-    "smap-client.d.ts": "ad701612630a290b2dc0e49250ae25cea965ecb3a145c016bb462cd30f108cf7",
-    "smap.mjs": "6639dc281f3af69b45164c842aa83d2096e002a0c55f41ab12aa4ad9878a34e0",
-    "smap.cjs": "37865209689abe5a06ee251dc21dcf977c16ddadcb02dddab37cb0b470d7822d",
-    "smap-client.cjs": "ab2b816c894027712082f23b944349cba6d7d33f1f262d1d2c495cddf07008bd",
-    "smap-client.mjs": "91587c5d58c1341ffdcd133c74aa8d393b23e5fe0d20fe5beac25e5f5bb6647b",
-    "smap-client.d.cts": "80b96f5a907caf6295ca073816dc526e8d285f22670c809adaab5242a018e686",
-    "smap-client.d.mts": "a66834cab868a6a0eaf943c1b185a236916cb00ecf32a871f972ab3213eddeba",
+    "smap-client.js": "026accb89f36a5b1c50c63eb4c124408ce01bdb66c2009dcac5dc235d7bfe0e3",
+    "smap-client.d.ts": "5f0df11bf60c5a9ced34522a284de81260c27871678ab772f16da9ccf6883f58",
+    "smap.mjs": "b92255fcf796f0e58b29b1c94d06a3b75d75d84247cd7264d6df4449f98123ee",
+    "smap.cjs": "4913c6d9e8741f50bf4620b66071caa9c23145f37d90c9480ec681f7d888d6b0",
+    "smap-client.cjs": "b722a6dcee9548bc917ca3c6dc79c311036cf2574b644053fe7450923d1b4b56",
+    "smap-client.mjs": "60d9cce0e0dd89fc4c01f8c35b3e1d18c994a88d25e2b73bf07e83c48a987a42",
+    "smap-client.d.cts": "e0fe4eb54cd66b831116082f42bd2f7de260f9f12a2741f4004f8cf10c252116",
+    "smap-client.d.mts": "96830d316ddb33b4ff8edb8b6f810337479636114f75c4170d95038ffda74103",
     "vendor-licenses.txt": "ee5fc05a0677eaf69601d2c7db0d9ecd6cc27c3abc1d0733bc9ed34707cf8ef2"
   }
 }

package/dist/smap-client.cjs

@@ -1,5 +1,5 @@
 /* Generated by js/build.mjs from js/src (see SOURCE.json). Do not edit. */
-/*! sMap JS client 1.0.6 — tokens, the nearest node, styles, tiles and raw reads, without a map view. */
+/*! sMap JS client 1.1.1 — tokens, the nearest node, styles, tiles and raw reads, without a map view. */
 /*
  * Runs wherever `fetch` exists: browsers, Node.js 18+, workers; elsewhere (mini programs, older runtimes) pass your
  * own `fetch`. UMD: `window.SMapClient`, `require('smap-client')`, or an AMD module.
@@ -19,7 +19,7 @@
 }(typeof self !== 'undefined' ? self : this, function () {
   'use strict';
 
-  var VERSION = '1.0.6';
+  var VERSION = '1.1.1';
   var NODE_TTL = 3600 * 1000;          // the measured order
   var KNOWN_TTL = 30 * 86400 * 1000;   // the last node list received, used when none can be read
 
@@ -234,11 +234,25 @@
     });
   };
 
-  SMapClient.prototype._demote = function (url) {
+  /**
+   * Reports that a node did not answer: it is tried last from now on (by this client's requests and by anything
+   * reading nodes()). Used by tools that read tiles themselves (the Leaflet, OpenLayers, Mapbox GL JS, deck.gl, ArcGIS
+   * and CesiumJS adapters) so that their requests and the client's agree.
+   *
+   * @param {string} url  a node URL as nodes() lists it
+   */
+  SMapClient.prototype.demote = function (url) {
     if (!this._nodes || this._nodes.length < 2) { return; }
+    url = String(url).replace(/\/$/, '');
     var i = this._nodes.indexOf(url);
     if (i >= 0) { this._nodes.splice(i, 1); this._nodes.push(url); }
   };
+  // The 1.0 name, kept for callers that used it.
+  SMapClient.prototype._demote = SMapClient.prototype.demote;
+
+  // The map key given to the client (null without one), and whether it renews its token (a getToken was given).
+  Object.defineProperty(SMapClient.prototype, 'apiKey', { get: function () { return this._apiKey; }, configurable: true });
+  Object.defineProperty(SMapClient.prototype, 'renewsToken', { get: function () { return !!this._getToken; }, configurable: true });
 
   function bytes(res) { return res.arrayBuffer().then(function (b) { return new Uint8Array(b); }); }
 

package/dist/smap-client.d.cts

@@ -32,6 +32,12 @@ declare class SMapClient {
   nodes(): Promise<string[]>;
   resetNodes(): void;
   request(path: string, headers?: Record<string, string>): Promise<Response>;
+  /** The map key given to the client, or null. */
+  readonly apiKey: string | null;
+  /** True when the client renews its token (a getToken was given). */
+  readonly renewsToken: boolean;
+  /** Reports that a node did not answer: it is tried last from now on. */
+  demote(url: string): void;
   style(flavor?: SMapClient.StyleFlavor, language?: string): Promise<Record<string, unknown>>;
   tileJSON(source?: string): Promise<Record<string, unknown>>;
   tile(source: string, z: number, x: number, y: number): Promise<Uint8Array | null>;

package/dist/smap-client.d.mts

@@ -32,6 +32,12 @@ declare class SMapClient {
   nodes(): Promise<string[]>;
   resetNodes(): void;
   request(path: string, headers?: Record<string, string>): Promise<Response>;
+  /** The map key given to the client, or null. */
+  readonly apiKey: string | null;
+  /** True when the client renews its token (a getToken was given). */
+  readonly renewsToken: boolean;
+  /** Reports that a node did not answer: it is tried last from now on. */
+  demote(url: string): void;
   style(flavor?: SMapClient.StyleFlavor, language?: string): Promise<Record<string, unknown>>;
   tileJSON(source?: string): Promise<Record<string, unknown>>;
   tile(source: string, z: number, x: number, y: number): Promise<Uint8Array | null>;

package/dist/smap-client.d.ts

@@ -31,6 +31,12 @@ declare class SMapClient {
   nodes(): Promise<string[]>;
   resetNodes(): void;
   request(path: string, headers?: Record<string, string>): Promise<Response>;
+  /** The map key given to the client, or null. */
+  readonly apiKey: string | null;
+  /** True when the client renews its token (a getToken was given). */
+  readonly renewsToken: boolean;
+  /** Reports that a node did not answer: it is tried last from now on. */
+  demote(url: string): void;
   style(flavor?: SMapClient.StyleFlavor, language?: string): Promise<Record<string, unknown>>;
   tileJSON(source?: string): Promise<Record<string, unknown>>;
   tile(source: string, z: number, x: number, y: number): Promise<Uint8Array | null>;

package/dist/smap-client.js

@@ -1,4 +1,4 @@
-/*! sMap JS client 1.0.6 — tokens, the nearest node, styles, tiles and raw reads, without a map view. */
+/*! sMap JS client 1.1.1 — tokens, the nearest node, styles, tiles and raw reads, without a map view. */
 /*
  * Runs wherever `fetch` exists: browsers, Node.js 18+, workers; elsewhere (mini programs, older runtimes) pass your
  * own `fetch`. UMD: `window.SMapClient`, `require('smap-client')`, or an AMD module.
@@ -18,7 +18,7 @@
 }(typeof self !== 'undefined' ? self : this, function () {
   'use strict';
 
-  var VERSION = '1.0.6';
+  var VERSION = '1.1.1';
   var NODE_TTL = 3600 * 1000;          // the measured order
   var KNOWN_TTL = 30 * 86400 * 1000;   // the last node list received, used when none can be read
 
@@ -233,11 +233,25 @@
     });
   };
 
-  SMapClient.prototype._demote = function (url) {
+  /**
+   * Reports that a node did not answer: it is tried last from now on (by this client's requests and by anything
+   * reading nodes()). Used by tools that read tiles themselves (the Leaflet, OpenLayers, Mapbox GL JS, deck.gl, ArcGIS
+   * and CesiumJS adapters) so that their requests and the client's agree.
+   *
+   * @param {string} url  a node URL as nodes() lists it
+   */
+  SMapClient.prototype.demote = function (url) {
     if (!this._nodes || this._nodes.length < 2) { return; }
+    url = String(url).replace(/\/$/, '');
     var i = this._nodes.indexOf(url);
     if (i >= 0) { this._nodes.splice(i, 1); this._nodes.push(url); }
   };
+  // The 1.0 name, kept for callers that used it.
+  SMapClient.prototype._demote = SMapClient.prototype.demote;
+
+  // The map key given to the client (null without one), and whether it renews its token (a getToken was given).
+  Object.defineProperty(SMapClient.prototype, 'apiKey', { get: function () { return this._apiKey; }, configurable: true });
+  Object.defineProperty(SMapClient.prototype, 'renewsToken', { get: function () { return !!this._getToken; }, configurable: true });
 
   function bytes(res) { return res.arrayBuffer().then(function (b) { return new Uint8Array(b); }); }
 

package/dist/smap-client.mjs

@@ -1,7 +1,7 @@
 /* Generated by js/build.mjs from js/src (see SOURCE.json). Do not edit. */
 var smapClientModule = { exports: {} };
 (function (module, exports, define) {
-/*! sMap JS client 1.0.6 — tokens, the nearest node, styles, tiles and raw reads, without a map view. */
+/*! sMap JS client 1.1.1 — tokens, the nearest node, styles, tiles and raw reads, without a map view. */
 /*
  * Runs wherever `fetch` exists: browsers, Node.js 18+, workers; elsewhere (mini programs, older runtimes) pass your
  * own `fetch`. UMD: `window.SMapClient`, `require('smap-client')`, or an AMD module.
@@ -21,7 +21,7 @@ var smapClientModule = { exports: {} };
 }(typeof self !== 'undefined' ? self : this, function () {
   'use strict';
 
-  var VERSION = '1.0.6';
+  var VERSION = '1.1.1';
   var NODE_TTL = 3600 * 1000;          // the measured order
   var KNOWN_TTL = 30 * 86400 * 1000;   // the last node list received, used when none can be read
 
@@ -236,11 +236,25 @@ var smapClientModule = { exports: {} };
     });
   };
 
-  SMapClient.prototype._demote = function (url) {
+  /**
+   * Reports that a node did not answer: it is tried last from now on (by this client's requests and by anything
+   * reading nodes()). Used by tools that read tiles themselves (the Leaflet, OpenLayers, Mapbox GL JS, deck.gl, ArcGIS
+   * and CesiumJS adapters) so that their requests and the client's agree.
+   *
+   * @param {string} url  a node URL as nodes() lists it
+   */
+  SMapClient.prototype.demote = function (url) {
     if (!this._nodes || this._nodes.length < 2) { return; }
+    url = String(url).replace(/\/$/, '');
     var i = this._nodes.indexOf(url);
     if (i >= 0) { this._nodes.splice(i, 1); this._nodes.push(url); }
   };
+  // The 1.0 name, kept for callers that used it.
+  SMapClient.prototype._demote = SMapClient.prototype.demote;
+
+  // The map key given to the client (null without one), and whether it renews its token (a getToken was given).
+  Object.defineProperty(SMapClient.prototype, 'apiKey', { get: function () { return this._apiKey; }, configurable: true });
+  Object.defineProperty(SMapClient.prototype, 'renewsToken', { get: function () { return !!this._getToken; }, configurable: true });
 
   function bytes(res) { return res.arrayBuffer().then(function (b) { return new Uint8Array(b); }); }