@superrouteca/smap-arcgis 0.0.0-stage → 1.1.1

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## 1.1.1 — 2026-10-27
+
+- The vector basemap draws: water, land, roads, labels and icons appear in every colour scheme and label language
+  (with 1.1.0, `createSMapBasemap()` and `createVectorTileLayer()` loaded without an error and drew nothing). The style
+  is converted into what ArcGIS's vector tile layer supports before it is handed over; sMap's own style is unchanged.
+- What the conversion simplifies, compared with the sMap web map: a label shows the name in the label language and,
+  for a name in another script, the local name on a second line, in one font (the per-script fonts are not used);
+  labels that sMap places at one of several positions keep the first position; layer properties ArcGIS does not
+  have are left out, and 3D buildings are drawn flat. `layer.smap.simplified` lists every simplification of the
+  style shown.
+- `toArcGISStyle()` converts any style the same way (for a `VectorTileLayer` of your own); `convertStyle: false`
+  hands sMap's style to ArcGIS unchanged.
+- Chinese, Japanese and Korean labels show in the vector basemap: sMap 1.1.1 serves them in its fonts. Chinese
+  characters take the Simplified Chinese form in every language.
+
+## 1.1.0 — 2026-10-27
+
+- First version.
+- sMap as an ArcGIS basemap: vector tiles in sMap's style (`createSMapBasemap`, `createVectorTileLayer`; the five
+  colour schemes, custom styles and labels in any language, restyled in place) or sMap's raster tiles
+  (`createRasterTileLayer`). The map key or token on every request, the nearest map node and the next one when a node
+  fails (`installInterceptor`); the sMap badge and the OpenStreetMap credit (`addAttribution`).
+- sMap's points, pins, lines and areas as ArcGIS graphics with the SDK's options and popups (`createGraphicsLayer`).
+- ArcGIS REST services on an sMap map (`addArcGisService`): tile and vector tile services, and feature layers read as
+  GeoJSON and coloured by their renderer.

package/LICENSE

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

package/README.md

@@ -1,3 +1,132 @@
-# Temporary Holding Version
+# @superrouteca/smap-arcgis
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+sMap and the [ArcGIS Maps SDK for JavaScript](https://developers.arcgis.com/javascript/) both ways:
+
+- **sMap as an ArcGIS basemap**: a `VectorTileLayer` with sMap's style and vector tiles (the five colour schemes and
+  your saved custom styles, labels in any language), or a `WebTileLayer` of sMap's raster tiles. The map key or token
+  goes on every request through ArcGIS request interceptors; requests go to the nearest map node and move to the next
+  one when a node fails; the sMap badge and the OpenStreetMap credit are shown.
+- **sMap's points, pins, lines and areas as ArcGIS graphics**, with the options of the SDK's `addPoints` / `addLines` /
+  `addPolygons` and popups as ArcGIS popups.
+- **ArcGIS REST services on an sMap map**: cached map and image services and vector tile services through the map's
+  `addArcGisLayer`, and feature layers queried as GeoJSON, coloured by their own renderer.
+
+```sh
+npm install @superrouteca/smap-arcgis @arcgis/core
+```
+
+`@arcgis/core` 5 is a peer dependency (not needed for `@superrouteca/smap-arcgis/services`). The adapter depends on
+`@superrouteca/smap` (1.1.0) for the nodes, the key and the token.
+
+## Access
+
+Every call takes the options of the sMap JS client: `apiKey` (a map key, `smk_…`, whose allowlist names your site),
+or `token` / `getToken` (short-lived tokens from your server), plus `baseUrl` (default `https://tile.srsr.ca`),
+`nodes` and `nearest`. Share one session between layers with `session: createSession({ … })`.
+
+## sMap as the basemap
+
+```js
+import Map from '@arcgis/core/Map.js';
+import MapView from '@arcgis/core/views/MapView.js';
+import { createSMapBasemap, addAttribution } from '@superrouteca/smap-arcgis';
+
+const basemap = await createSMapBasemap({ apiKey: 'smk_…', style: 'light', language: 'fr' });
+const view = new MapView({ container: 'map', map: new Map({ basemap }), center: [2.35, 48.86], zoom: 12 });
+addAttribution(view);   // the sMap badge and the OpenStreetMap credit, bottom right
+```
+
+An existing ArcGIS app switches its basemap and keeps every layer: `map.basemap = await createSMapBasemap({ … })`.
+
+- `style`: `light`, `white`, `grayscale`, `dark`, `black`, or a saved custom style `custom:sms_…`.
+- `raster: true` uses sMap's raster tiles (a `WebTileLayer`, `retina: true` for 512 px images): the exact sMap look
+  wherever vector tiles are not wanted, and in a `SceneView` as draped imagery.
+- `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.
+
+The layers on their own: `createVectorTileLayer(options)` and `createRasterTileLayer(options)`.
+
+### The vector style in ArcGIS
+
+ArcGIS's `VectorTileLayer` supports part of the Style Specification, so the vector basemap converts sMap's style
+before handing it over (`toArcGISStyle(style)` does the same for a `VectorTileLayer` of your own; `convertStyle: false`
+hands the style over unchanged). Compared with the sMap web map:
+
+- a label shows the name in the label language and, for a name in another script, the local name on a second line,
+  in one font;
+- a label that sMap places at one of several positions keeps the first one;
+- layer properties ArcGIS does not have are left out, and 3D buildings are drawn flat;
+- Chinese, Japanese and Korean labels are drawn with sMap's own fonts (sMap 1.1.1 or later); Chinese characters take
+  the Simplified Chinese form in every language.
+
+`basemap.smap.simplified` lists each simplification of the style shown (`"<layer>: <what>"`).
+
+### Keys, tokens and nodes
+
+`createSMapBasemap` (and the layer functions) install one request interceptor per session
+(`installInterceptor(session)`, returning `{ remove() }`): every request to an sMap node is sent to the node read from
+now, with `Authorization: Bearer <token>` and `X-SMap-Key` headers; a network error or a 5xx answer moves the session
+to the next node, so the tiles that follow come from it. A map key also travels in the style's own tile URLs, so key
+access works even where a request does not pass through the interceptors. Tokens are renewed in the background
+before they expire.
+
+ArcGIS draws the Style Specification styles it supports; sMap's schemes keep to what it reads. 3D buildings are not
+drawn by ArcGIS from vector tiles: in a `SceneView` the sMap basemap is a flat, draped layer.
+
+## sMap's layers as graphics
+
+```js
+import { createGraphicsLayer } from '@superrouteca/smap-arcgis';
+import { popupTemplate } from '@superrouteca/smap';
+
+view.map.addMany([
+  createGraphicsLayer('zones', 'areas', zones, { fill: '#2563eb', opacity: 0.2, outline: '#2563eb' }),
+  createGraphicsLayer('route', 'lines', route, { color: { property: 'color' }, width: 5 }),
+  createGraphicsLayer('stops', 'points', stops, {
+    marker: { border: { property: 'color' } }, label: 'name',
+    popup: popupTemplate('<b>{name}</b><br>{address}'), popupTitle: 'Stop',
+  }),
+]);
+```
+
+Points: circles, an icon, or pins (`pin` and `circle` shapes, fill, border); lines: colour per feature, width,
+opacity, dashes; areas: fill, outline, opacity; `minzoom` / `maxzoom` become the layer's scale range; a `label` is a
+text graphic beside each point. GeoJSON simplestyle properties colour a layer that gives no colour of its own. The
+`popup` option is each graphic's popup content (a string, a DOM node or a promise of either). Numbers inside pins,
+count badges, casings, arrows, clustering, extrusion and Auto Zoom are not drawn here; they are the sMap map's own.
+
+## ArcGIS services on an sMap map
+
+```js
+import * as sMap from '@superrouteca/smap';
+import { addArcGisService } from '@superrouteca/smap-arcgis/services';
+
+const map = new sMap.Map({ container: 'map', apiKey: 'smk_…' });
+await map.ready;
+await addArcGisService(map, 'hillshade', 'https://services.arcgisonline.com/arcgis/rest/services/Elevation/World_Hillshade/MapServer', { slot: 'bottom' });
+await addArcGisService(map, 'parcels', 'https://example.com/arcgis/rest/services/Parcels/FeatureServer/0', {
+  token: arcgisToken, where: "zoning = 'R1'", layerOptions: { popup: sMap.popupTemplate('{address}') },
+});
+```
+
+- Cached `MapServer` / `ImageServer` and `VectorTileServer` services go through the map's
+  `addArcGisLayer(id, { url, attribution, slot, ...layerOptions })`, which reads the service (its tile size, its
+  vector tile style, and its copyright text as the default attribution).
+- One layer of a feature or map service (`…/FeatureServer/0`, `…/MapServer/2`) is queried as GeoJSON in WGS 84, page
+  by page (`maxFeatures`, default 50,000), coloured by the layer's simple or unique-value renderer, and added with
+  `map.addData` (points, lines and areas as `<id>`, `<id>:lines` and `<id>:areas`).
+- `token` is an ArcGIS token for secured services. `slot` is passed only when given; a layer without one is drawn on
+  top, in the order added.
+- Helpers: `queryFeatures(url, options)`, `serviceInfo(url)`, `parseServiceUrl(url)`, `rendererStyle`,
+  `symbolToSimplestyle`.
+
+## Example
+
+[`examples/index.html`](examples/index.html): serve the repository root (`npx serve .`) and open
+`/arcgis/examples/?key=smk_…` (`&raster=1` for raster tiles).
+
+## Licence
+
+MIT. The map data is © OpenStreetMap contributors; the credit stays visible on every map.

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "@superrouteca/smap-arcgis",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.1",
+  "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",
+  "homepage": "https://github.com/Goodneo-Solutions/smap-sdk/tree/main/arcgis#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Goodneo-Solutions/smap-sdk.git",
+    "directory": "arcgis"
+  },
+  "keywords": [
+    "map",
+    "maps",
+    "arcgis",
+    "esri",
+    "vector-tiles",
+    "smap",
+    "superroute"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./services": {
+      "types": "./types/services.d.ts",
+      "default": "./src/services.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "types",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --import ./test/setup.mjs --test test/*.test.mjs",
+    "typecheck": "tsc -p test/tsconfig.json"
+  },
+  "dependencies": {
+    "@superrouteca/smap": "1.1.1"
+  },
+  "peerDependencies": {
+    "@arcgis/core": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@arcgis/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arcgis/core": "5.1.27",
+    "@maplibre/maplibre-gl-style-spec": "26.4.4",
+    "typescript": "6.0.3"
+  }
+}

package/src/basemap.js

@@ -0,0 +1,180 @@
+// sMap in the ArcGIS Maps SDK for JavaScript: a VectorTileLayer with sMap's style and vector tiles (the five schemes
+// and custom styles, labels in any language), a WebTileLayer of sMap's raster tiles where vector tiles are not wanted,
+// the map key / token on every request through ArcGIS request interceptors, the nearest node with failover, and the
+// sMap badge with the OpenStreetMap credit.
+import esriConfig from '@arcgis/core/config.js';
+import Basemap from '@arcgis/core/Basemap.js';
+import VectorTileLayer from '@arcgis/core/layers/VectorTileLayer.js';
+import WebTileLayer from '@arcgis/core/layers/WebTileLayer.js';
+import { applyBasemapOverrides } from '@superrouteca/smap';
+import { createSession, ATTRIBUTION } from './session.js';
+import { toArcGISStyle } from './style.js';
+
+const installed = new WeakMap();
+
+function escapeRegExp(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+function urlsFor(session) {
+  return new RegExp('^(' + session.origins().map(escapeRegExp).join('|') + ')(/|$)');
+}
+
+/**
+ * Adds an ArcGIS request interceptor for sMap URLs: each request goes to the node read from now (so a node that
+ * failed is left), with the token and the map key as headers; a failed request moves the session to the next node.
+ * Installed once per session; returns `{ interceptor, remove() }`.
+ */
+export function installInterceptor(sessionOrOptions) {
+  const session = createSession(sessionOrOptions);
+  if (installed.has(session)) { return installed.get(session); }
+  const interceptor = {
+    urls: urlsFor(session),
+    before(params) {
+      if (!params || !params.url || !session.nodeOf(params.url)) { return undefined; }
+      params.url = session.rebase(params.url);
+      const ro = params.requestOptions || (params.requestOptions = {});
+      ro.headers = { ...(ro.headers || {}), ...session.headers() };
+      return undefined;
+    },
+    error(error) {
+      const details = (error && error.details) || {};
+      const url = details.url || (error && error.url);
+      const status = details.httpStatus || details.status || 0;
+      // 4xx answers are final (a refused key stays refused on every node); network errors and 5xx move on.
+      if (url && session.nodeOf(url) && (status === 0 || status >= 500)) { session.failed(url); }
+    },
+  };
+  const update = () => { interceptor.urls = urlsFor(session); };
+  const offNode = session.on('nodechange', update);
+  session.ready().then(update, () => {});
+  esriConfig.request.interceptors = esriConfig.request.interceptors || [];
+  esriConfig.request.interceptors.push(interceptor);
+  const handle = {
+    interceptor,
+    remove() {
+      offNode();
+      const list = esriConfig.request.interceptors;
+      const i = list.indexOf(interceptor);
+      if (i >= 0) { list.splice(i, 1); }
+      installed.delete(session);
+    },
+  };
+  installed.set(session, handle);
+  return handle;
+}
+
+/**
+ * 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.
+ *
+ * `basemap` shows, hides and recolours classes (as the sMap map's setBasemap).
+ *
+ * @returns {Promise<VectorTileLayer>} with `smap: { session, style, language, setStyle, setLanguage, setBasemap, basemap }`
+ */
+export async function createVectorTileLayer(options = {}) {
+  const session = createSession(options.session || options);
+  installInterceptor(session);
+  await session.ready();
+  let style = options.style || 'light';
+  let language = options.language;
+  let overrides = options.basemap || null;
+  let simplified = [];
+  // Basemap options (contract §1: show, hide and recolour by class), applied by the SDK's own function; then the
+  // style is converted into what ArcGIS's VectorTileLayer draws (style.js; `convertStyle: false` hands it over as is).
+  const styled = async () => {
+    const doc = await session.style(style, language);
+    const own = overrides && Object.keys(overrides).length ? applyBasemapOverrides(doc, overrides) : doc;
+    if (options.convertStyle === false) { simplified = []; return own; }
+    const changes = [];
+    const out = toArcGISStyle(own, { language, changes });
+    simplified = changes;
+    return out;
+  };
+  const layer = new VectorTileLayer({
+    id: options.id || 'smap-vector',
+    title: options.title || 'sMap',
+    style: await styled(),
+    ...(options.layerProps || {}),
+  });
+  const reload = async () => { await layer.loadStyle(await styled()); return layer; };
+  layer.smap = {
+    session,
+    get style() { return style; },
+    get language() { return language; },
+    basemap() { return overrides ? { ...overrides } : {}; },
+    /** What the conversion for ArcGIS simplified in the style now shown, one line per layer and property. */
+    get simplified() { return simplified.slice(); },
+    setStyle(next) { style = next; return reload(); },
+    setLanguage(next) { language = next; return reload(); },
+    setBasemap(next) { overrides = next && Object.keys(next).length ? { ...next } : null; return reload(); },
+  };
+  return layer;
+}
+
+/**
+ * A WebTileLayer of sMap's raster tiles (contract §5): the same schemes, custom styles and languages as images drawn on
+ * sMap's nodes. `retina` reads 512 px tiles (the @2x images of the same tiles, shown in the 256 px grid). The layer's
+ * copyright is the OpenStreetMap credit.
+ */
+export async function createRasterTileLayer(options = {}) {
+  const session = createSession(options.session || options);
+  installInterceptor(session);
+  await session.ready();
+  const style = options.style || 'light';
+  const urlTemplate = session.rasterTemplate(style, {
+    language: options.language,
+    retina: options.retina,
+    placeholders: { z: '{level}', x: '{col}', y: '{row}' },
+  });
+  const layer = new WebTileLayer({
+    id: options.id || 'smap-raster',
+    title: options.title || 'sMap',
+    urlTemplate,
+    copyright: ATTRIBUTION,
+    ...(options.layerProps || {}),
+  });
+  layer.smap = { session, style, language: options.language };
+  return layer;
+}
+
+/**
+ * An sMap basemap for a Map or WebMap (`map.basemap = await createSMapBasemap({ … })`): vector tiles by default,
+ * raster tiles with `raster: true`. An existing ArcGIS app switches its basemap to sMap and keeps its layers.
+ */
+export async function createSMapBasemap(options = {}) {
+  const style = options.style || 'light';
+  const layer = options.raster ? await createRasterTileLayer(options) : await createVectorTileLayer(options);
+  const basemap = new Basemap({
+    id: options.basemapId || 'smap-' + style.replace(':', '-'),
+    title: options.title || 'sMap ' + style.replace(/^custom:/, ''),
+    baseLayers: [layer],
+    thumbnailUrl: layer.smap.session.rasterTemplate(style, { language: options.language }).replace('{z}', '3').replace('{x}', '2').replace('{y}', '2'),
+  });
+  basemap.smap = layer.smap;
+  return basemap;
+}
+
+const BADGE_ICON = '<svg viewBox="0 0 56 56" width="14" height="14" aria-hidden="true" focusable="false">' +
+  '<rect x="2" y="2" width="52" height="52" rx="13" fill="#2563eb"/>' +
+  '<path d="M38 15H22a8 8 0 0 0 0 16h12a8 8 0 0 1 0 16H18" fill="none" stroke="#fff" stroke-width="7" ' +
+  'stroke-linecap="round" stroke-linejoin="round"/></svg>';
+
+/**
+ * The sMap badge and the OpenStreetMap credit in the view's bottom-right corner (beside ArcGIS's own attribution,
+ * which stays). Returns the element.
+ */
+export function addAttribution(view, options = {}) {
+  const doc = options.document || (view.container && view.container.ownerDocument) || globalThis.document;
+  const el = doc.createElement('div');
+  el.className = 'smap-arcgis-attribution esri-widget';
+  el.setAttribute('style', 'display:flex;gap:6px;align-items:center;padding:2px 6px;font:11px/16px Helvetica,Arial,sans-serif;background:rgba(255,255,255,.8)');
+  const badge = doc.createElement('span');
+  badge.className = 'smap-badge';
+  badge.setAttribute('style', 'display:inline-flex;gap:3px;align-items:center;font-weight:600');
+  badge.innerHTML = BADGE_ICON + '<span>sMap</span>';
+  const credit = doc.createElement('span');
+  credit.textContent = ATTRIBUTION;
+  el.appendChild(badge);
+  el.appendChild(credit);
+  view.ui.add(el, 'bottom-right');
+  return el;
+}

package/src/graphics.js

@@ -0,0 +1,169 @@
+// sMap's points, lines and areas as an ArcGIS GraphicsLayer, with the options of the sMap SDK's addPoints / addLines /
+// addPolygons and the layer's popup as the graphics' PopupTemplate. GeoJSON simplestyle properties colour a layer that
+// gives no colour of its own.
+import Graphic from '@arcgis/core/Graphic.js';
+import GraphicsLayer from '@arcgis/core/layers/GraphicsLayer.js';
+
+const GEOMETRY_TYPES = ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'];
+const WGS84 = { wkid: 4326 };
+
+/** sMap layer data (a FeatureCollection, a Feature, a geometry, or an array of points / features) as features. */
+export function toFeatures(data) {
+  if (!data) { return []; }
+  if (data.type === 'FeatureCollection') { return data.features || []; }
+  if (data.type === 'Feature') { return [data]; }
+  if (GEOMETRY_TYPES.includes(data.type)) { return [{ type: 'Feature', properties: {}, geometry: data }]; }
+  if (Array.isArray(data)) {
+    return data.map((p) => {
+      if (p && p.type === 'Feature') { return p; }
+      let lng = p.lng ?? p.lon ?? p.longitude;
+      let lat = p.lat ?? p.latitude;
+      if (p.coordinates) { [lng, lat] = p.coordinates; }
+      return { type: 'Feature', id: p.id, properties: p, geometry: { type: 'Point', coordinates: [lng, lat] } };
+    });
+  }
+  return [];
+}
+
+function signedArea(ring) {
+  let a = 0;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) { a += (ring[i][0] - ring[j][0]) * (ring[i][1] + ring[j][1]); }
+  return a / 2; // > 0: clockwise
+}
+
+// ArcGIS polygons: outer rings clockwise, holes counter-clockwise (GeoJSON is the other way round).
+function rings(polygon) {
+  return polygon.map((ring, i) => {
+    const cw = signedArea(ring) > 0;
+    return (i === 0) === cw ? ring : ring.slice().reverse();
+  });
+}
+
+/** GeoJSON geometry → ArcGIS geometry (autocast object, WGS 84); GeometryCollection → several. */
+export function toArcGisGeometries(g) {
+  if (!g) { return []; }
+  switch (g.type) {
+    case 'Point': return [{ type: 'point', longitude: g.coordinates[0], latitude: g.coordinates[1], spatialReference: WGS84 }];
+    case 'MultiPoint': return [{ type: 'multipoint', points: g.coordinates, spatialReference: WGS84 }];
+    case 'LineString': return [{ type: 'polyline', paths: [g.coordinates], spatialReference: WGS84 }];
+    case 'MultiLineString': return [{ type: 'polyline', paths: g.coordinates, spatialReference: WGS84 }];
+    case 'Polygon': return [{ type: 'polygon', rings: rings(g.coordinates), spatialReference: WGS84 }];
+    case 'MultiPolygon': return [{ type: 'polygon', rings: g.coordinates.flatMap(rings), spatialReference: WGS84 }];
+    case 'GeometryCollection': return (g.geometries || []).flatMap(toArcGisGeometries);
+    default: return [];
+  }
+}
+
+function read(value, props, fallback, simplestyleKey) {
+  let v;
+  if (value === undefined || value === null) { v = simplestyleKey ? props[simplestyleKey] : undefined; }
+  else if (typeof value === 'object' && !Array.isArray(value) && value.property) { v = props[value.property] ?? value.default; }
+  else if (Array.isArray(value) && value.length === 2 && value[0] === 'get') { v = props[value[1]]; }
+  else { v = value; }
+  return v === undefined || v === null ? fallback : v;
+}
+
+function pinSvg(fill, border, width, round) {
+  const svg = round
+    ? '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32"><circle cx="16" cy="16" r="' + (15 - width / 2) + '" fill="' + fill + '" stroke="' + border + '" stroke-width="' + width + '"/></svg>'
+    : '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="42" viewBox="0 0 32 42"><path d="M16 40.5C16 40.5 2.5 25 2.5 15.5a13.5 13.5 0 1 1 27 0C29.5 25 16 40.5 16 40.5Z" fill="' + fill + '" stroke="' + border + '" stroke-width="' + width + '" stroke-linejoin="round"/></svg>';
+  return 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svg);
+}
+
+const SIZES = { small: 8, medium: 12, large: 18 };
+
+/** The ArcGIS symbol of one feature for sMap point / line / area options. */
+export function symbolFor(kind, props, options = {}) {
+  if (kind === 'points') {
+    const mk = options.marker;
+    if (mk) {
+      const round = mk.shape === 'circle' || mk.shape === 'vehicle';
+      const size = mk.size || 32;
+      const border = read(mk.border, props, read(options.color, props, '#2563eb', 'marker-color'));
+      return {
+        type: 'picture-marker', url: pinSvg(read(mk.fill, props, '#ffffff'), border, mk.borderWidth ?? 3, round),
+        width: size * 0.75, height: (round ? size : size * 42 / 32) * 0.75, yoffset: round ? 0 : size * 42 / 32 * 0.375,
+      };
+    }
+    if (options.icon) {
+      const s = (options.iconSize || 1) * 24;
+      return { type: 'picture-marker', url: options.icon, width: s, height: s };
+    }
+    const radius = options.radius ?? (SIZES[props['marker-size']] ? SIZES[props['marker-size']] / 2 : 6);
+    return {
+      type: 'simple-marker', style: 'circle', size: radius * 1.5,
+      color: read(options.color, props, '#2563eb', 'marker-color'),
+      outline: { color: read(options.strokeColor, props, '#ffffff'), width: (options.strokeWidth ?? 2) * 0.75 },
+    };
+  }
+  if (kind === 'lines') {
+    const color = read(options.color, props, '#2563eb', 'stroke');
+    const width = options.width ?? props['stroke-width'] ?? 4;
+    const dash = Array.isArray(options.dash) && options.dash.length ? 'dash' : 'solid';
+    return { type: 'simple-line', color: withAlpha(color, options.opacity ?? props['stroke-opacity']), width: width * 0.75, style: dash, cap: 'round', join: 'round' };
+  }
+  const fill = read(options.fill ?? options.color, props, '#2563eb', 'fill');
+  return {
+    type: 'simple-fill',
+    color: withAlpha(fill, options.opacity ?? props['fill-opacity'] ?? 0.3),
+    outline: { color: read(options.outline, props, fill, 'stroke'), width: (options.outlineWidth ?? 1) * 0.75 },
+  };
+}
+
+function withAlpha(color, alpha) {
+  if (alpha === undefined || alpha === null) { return color; }
+  if (typeof color === 'string' && /^#[0-9a-f]{6}$/i.test(color)) {
+    const n = (i) => parseInt(color.slice(i, i + 2), 16);
+    return [n(1), n(3), n(5), alpha];
+  }
+  return color;
+}
+
+/**
+ * A GraphicsLayer of sMap layer data. `kind` is `points`, `lines` or `areas` (the SDK's addPoints, addLines,
+ * addPolygons options apply); the `popup` option becomes each graphic's PopupTemplate (content from the feature's
+ * attributes; a promise is awaited by the popup), and `label` a text graphic beside each point.
+ */
+export function createGraphicsLayer(id, kind, data, options = {}) {
+  if (!['points', 'lines', 'areas'].includes(kind)) { throw new Error('sMap: kind is points, lines or areas, not "' + kind + '"'); }
+  const graphics = [];
+  const want = { points: /Point$/, lines: /LineString$/, areas: /Polygon$/ }[kind];
+  for (const f of toFeatures(data)) {
+    const props = { ...(f.properties || {}) };
+    const parts = f.geometry && f.geometry.type === 'GeometryCollection' ? f.geometry.geometries || [] : [f.geometry];
+    const geometries = parts.filter((g) => g && want.test(g.type)).flatMap(toArcGisGeometries);
+    for (const geometry of geometries) {
+      const graphic = { geometry, attributes: props, symbol: symbolFor(kind, props, options) };
+      if (options.popup) {
+        graphic.popupTemplate = {
+          title: options.popupTitle || '',
+          content: (event) => {
+            const attrs = (event && event.graphic && event.graphic.attributes) || props;
+            return options.popup(attrs, f);
+          },
+        };
+      }
+      graphics.push(new Graphic(graphic));
+      if (kind === 'points' && options.label && props[options.label] != null) {
+        const right = options.labelPosition === 'right';
+        graphics.push(new Graphic({
+          geometry, attributes: props,
+          symbol: {
+            type: 'text', text: String(props[options.label]), color: '#333333', haloColor: '#ffffff', haloSize: 1.5,
+            font: { size: 9, family: 'sans-serif' }, horizontalAlignment: right ? 'left' : 'center',
+            xoffset: right ? 12 : 0, yoffset: right ? 0 : -14,
+          },
+        }));
+      }
+    }
+  }
+  const layer = new GraphicsLayer({ id, title: options.title || id, graphics, ...(options.layerProps || {}) });
+  if (options.minzoom !== undefined) { layer.minScale = zoomToScale(options.minzoom); }
+  if (options.maxzoom !== undefined) { layer.maxScale = zoomToScale(options.maxzoom); }
+  return layer;
+}
+
+/** The Web Mercator map scale at a zoom (96 dpi, 256 px tiles), for minScale / maxScale. */
+export function zoomToScale(zoom) {
+  return 591657527.591555 / Math.pow(2, zoom);
+}

package/src/index.js

@@ -0,0 +1,7 @@
+// @superrouteca/smap-arcgis — sMap and the ArcGIS Maps SDK for JavaScript both ways.
+export { Session, createSession, FLAVORS, ATTRIBUTION } from './session.js';
+export { installInterceptor, createVectorTileLayer, createRasterTileLayer, createSMapBasemap, addAttribution } from './basemap.js';
+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';