@superrouteca/smap-arcgis 1.1.1 → 1.1.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.1.2 — 2026-10-27
+
+- Restyling quickly no longer logs errors: `setStyle()`, `setLanguage()` and `setBasemap()` called in quick
+  succession are applied one at a time and the latest call wins. A call that a newer one replaced resolves quietly
+  instead of rejecting with "Request canceled"; a real failure (network, a style that does not load) still rejects.
+- A restyle started while the map switches between the raster and the vector basemap waits until the vector layer is
+  shown again and then applies to it, and a basemap switched away from during a restyle no longer reports "Cannot read
+  properties of null (reading 'setStyleResources')". Removing the basemap during a restyle throws nothing.
+
 ## 1.1.1 — 2026-10-27
 
 - The vector basemap draws: water, land, roads, labels and icons appear in every colour scheme and label language

package/README.md

@@ -44,7 +44,11 @@ An existing ArcGIS app switches its basemap and keeps every layer: `map.basemap
 - `basemap: { pois: { visible: false }, roads: { color: '#ffffff' } }` shows, hides and recolours the basemap by
   class (vector), as the sMap map's `setBasemap`.
 - `basemap.smap.setStyle(style)` / `setLanguage(language)` / `setBasemap(overrides)` (vector) restyle the layer in
-  place.
+  place. Calls in quick succession (buttons clicked fast) are applied one at a time and the latest call wins: a state
+  replaced before it loaded is skipped, and a style is loaded only once the layer view is ready (also right after the
+  map's basemap was switched back to it). Each call returns a promise of the layer: the latest call resolves when its
+  state is shown and rejects when it fails (network, a style that does not load); a call that a newer one superseded
+  resolves with the layer once the newer call has settled and never rejects, so handlers need no `catch` for it.
 
 The layers on their own: `createVectorTileLayer(options)` and `createRasterTileLayer(options)`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superrouteca/smap-arcgis",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "sMap for the ArcGIS Maps SDK for JavaScript: sMap basemaps (vector and raster), sMap layers as graphics, and ArcGIS REST services on sMap maps.",
   "license": "MIT",
   "author": "Goodneo Solutions",
@@ -50,7 +50,7 @@
     "typecheck": "tsc -p test/tsconfig.json"
   },
   "dependencies": {
-    "@superrouteca/smap": "1.1.1"
+    "@superrouteca/smap": "1.1.2"
   },
   "peerDependencies": {
     "@arcgis/core": "^5.0.0"

package/src/basemap.js

@@ -62,6 +62,122 @@ export function installInterceptor(sessionOrOptions) {
   return handle;
 }
 
+function isAbort(error) {
+  return !!error && (error.name === 'AbortError' || error.name === 'cancel' || /^cancell?ed:/.test(String(error.name || '')));
+}
+
+/**
+ * The views that drew the layer (learnt from its layerview-create events), the layer views it has now, and a guard
+ * on each of those layer views: ArcGIS 5.x's VectorTileLayerView2D reads its tile container after awaiting the
+ * sprites of a new style, and the container is gone when the layer view was detached meanwhile (the basemap switched
+ * away during a restyle), which ArcGIS raised as an unhandled "Cannot read properties of null
+ * (reading 'setStyleResources')". A failure of a layer view that is no longer attached is dropped; any other is kept.
+ */
+function trackLayerViews(layer) {
+  const views = new Set();
+  const layerViews = new Set();
+  const guard = (lv) => {
+    if (!lv || lv.__smapGuarded || typeof lv._loadStyle !== 'function') { return; }
+    const own = lv._loadStyle;
+    lv._loadStyle = function smapGuardedLoadStyle(...args) {
+      const gone = () => this.destroyed || this.attached === false || !this._vectorTileContainer;
+      try {
+        return Promise.resolve(own.apply(this, args)).catch((error) => { if (gone()) { return undefined; } throw error; });
+      } catch (error) {
+        if (gone()) { return Promise.resolve(); }
+        throw error;
+      }
+    };
+    lv.__smapGuarded = true;
+  };
+  if (typeof layer.on === 'function') {
+    layer.on('layerview-create', (e) => {
+      if (e && e.view) { views.add(e.view); }
+      if (e && e.layerView) { layerViews.add(e.layerView); guard(e.layerView); }
+    });
+    layer.on('layerview-destroy', (e) => { if (e && e.layerView) { layerViews.delete(e.layerView); } });
+  }
+  return {
+    /**
+     * Resolves once every view that shows the layer has its layer view (one being created after a basemap switch is
+     * waited for); a view that drops the layer meanwhile is left out. Never rejects.
+     */
+    async settled() {
+      const waits = [];
+      for (const view of views) {
+        if (!view || view.destroyed) { views.delete(view); continue; }
+        const all = view.map && view.map.allLayers;
+        const shown = all && typeof all.includes === 'function' ? all.includes(layer) : false;
+        if (!shown || typeof view.whenLayerView !== 'function') { continue; }
+        waits.push(Promise.resolve().then(() => view.whenLayerView(layer)).then((lv) => {
+          guard(lv);
+          return typeof (lv && lv.when) === 'function' ? lv.when() : lv;
+        }).catch(() => undefined));
+      }
+      await Promise.all(waits);
+    },
+  };
+}
+
+/**
+ * Restyles `layer` with what `styled()` gives for the state wanted now. Calls are serialised and coalesced, so the
+ * latest call wins: one restyle runs at a time, a state that was replaced before it was loaded is not loaded, and the
+ * style is loaded only once the layer's layer views are ready (never into one being re-created after a basemap
+ * switch). Each call returns a promise of the layer: the latest call resolves when its state is shown and rejects
+ * when it fails (network, a style that does not load); a call that a newer one superseded resolves with the layer once
+ * the newer call has settled, and never rejects. A destroyed layer (the basemap removed) resolves every call.
+ */
+function restyler(layer, styled) {
+  const views = trackLayerViews(layer);
+  let wanted = 0;
+  let running = false;
+  const waiting = [];
+  const gone = () => !!layer.destroyed;
+  const settle = (upTo, error) => {
+    for (let i = waiting.length - 1; i >= 0; i--) {
+      const w = waiting[i];
+      if (w.gen > upTo) { continue; }
+      waiting.splice(i, 1);
+      if (error && w.gen === upTo) { w.reject(error); } else { w.resolve(layer); }
+    }
+  };
+  const run = async () => {
+    running = true;
+    let aborts = 0;
+    try {
+      while (waiting.length) {
+        const gen = wanted;
+        if (gone()) { settle(gen); break; }
+        try {
+          const doc = await styled();
+          if (gen !== wanted || gone()) { continue; }
+          await views.settled();
+          if (gen !== wanted || gone()) { continue; }
+          await layer.loadStyle(doc);
+          if (gen !== wanted) { continue; }
+          aborts = 0;
+          settle(gen);
+        } catch (error) {
+          if (gone()) { settle(wanted); break; }
+          if (gen !== wanted) { continue; }
+          // Cancelled by something else than this adapter (another loadStyle on the layer): try again, twice at most.
+          if (isAbort(error) && aborts++ < 2) { continue; }
+          aborts = 0;
+          settle(gen, error);
+        }
+      }
+    } finally {
+      running = false;
+    }
+  };
+  return () => {
+    const gen = ++wanted;
+    const promise = new Promise((resolve, reject) => { waiting.push({ gen, resolve, reject }); });
+    if (!running) { run(); }
+    return promise;
+  };
+}
+
 /**
  * A VectorTileLayer drawing sMap's vector tiles in a scheme or custom style, labels in `language`. The style is read
  * through the session (nearest node, failover, key, token); tiles, fonts and sprites through the interceptor.
@@ -95,7 +211,7 @@ export async function createVectorTileLayer(options = {}) {
     style: await styled(),
     ...(options.layerProps || {}),
   });
-  const reload = async () => { await layer.loadStyle(await styled()); return layer; };
+  const reload = restyler(layer, styled);
   layer.smap = {
     session,
     get style() { return style; },

package/src/index.js

@@ -4,4 +4,4 @@ export { installInterceptor, createVectorTileLayer, createRasterTileLayer, creat
 export { toArcGISStyle, styleLanguage, nameExpression } from './style.js';
 export { createGraphicsLayer, symbolFor, toArcGisGeometries, toFeatures, zoomToScale } from './graphics.js';
 export { addArcGisService, queryFeatures, serviceInfo, parseServiceUrl, withToken, symbolToSimplestyle, rendererStyle } from './services.js';
-export const version = '1.1.1';
+export const version = '1.1.2';

package/types/index.d.ts

@@ -81,6 +81,11 @@ export interface SMapLayerInfo {
   readonly language?: string;
 }
 export interface SMapVectorInfo extends SMapLayerInfo {
+  /**
+   * setStyle / setLanguage / setBasemap are applied one at a time and the latest call wins. The latest call resolves
+   * when its state is shown and rejects when it fails; a call a newer one superseded resolves with the layer once the
+   * newer call has settled and never rejects.
+   */
   setStyle(style: StyleName): Promise<VectorTileLayer>;
   setLanguage(language: string): Promise<VectorTileLayer>;
   /** Basemap options by class (contract §1), replacing the previous ones; `{}` clears. */