@superrouteca/smap-openlayers 0.0.0-stage → 1.1.0

package/src/on-smap.js

@@ -0,0 +1,273 @@
+// @superrouteca/smap-openlayers/on-smap — OpenLayers sources and layers on an sMap map, through the sMap map's own
+// calls (addRasterLayer, addWmsLayer, addWmtsLayer, addVectorTiles, addData / addPoints / addLines / addPolygons):
+//
+//   import { addOpenLayersLayer } from '@superrouteca/smap-openlayers/on-smap';
+//   addOpenLayersLayer(smapMap, 'radar', new TileLayer({ source: new TileWMS({ url, params: { LAYERS: 'radar' } }) }));
+//
+// Tiles: XYZ (and OSM, TileImage, TileJSON), TileWMS / ImageWMS, WMTS, VectorTile (with Style Specification layers,
+// as OpenLayers style functions have no counterpart). Features: a Vector source (GeoJSON written in WGS 84; a layer's
+// fixed Style becomes the colours). A layer without `slot` / `before` draws on top in the order added, as in 1.0.
+
+/** `{a-c}` and `{0-3}` ranges of OpenLayers URL templates, expanded; `{-y}` becomes `{y}` (TMS). */
+export function expandTemplates(urls) {
+  const out = [];
+  (urls || []).forEach(function (u) {
+    const m = /\{([a-z0-9])-([a-z0-9])\}/i.exec(u);
+    if (!m) { out.push(u); return; }
+    const a = m[1].charCodeAt(0);
+    const b = m[2].charCodeAt(0);
+    for (let c = a; c <= b; c++) { out.push.apply(out, expandTemplates([u.replace(m[0], String.fromCharCode(c))])); }
+  });
+  return out.map(function (u) { return u.replace(/\{-y\}/g, '{y}'); });
+}
+
+function attributionOf(source) {
+  const a = source && source.getAttributions && source.getAttributions();
+  if (!a) { return undefined; }
+  let v = a;
+  if (typeof a === 'function') {
+    try { v = a({ viewState: { projection: null, resolution: 1, center: [0, 0], zoom: 0, rotation: 0 }, extent: null }); } catch (e) { v = null; }
+  }
+  if (Array.isArray(v)) { return v.join(' ') || undefined; }
+  return v || undefined;
+}
+
+function placement(options) {
+  const p = {};
+  if (options.slot) { p.slot = options.slot; }
+  if (options.before) { p.before = options.before; }
+  if (options.zIndex !== undefined) { p.zIndex = options.zIndex; }
+  return p;
+}
+
+function zoomRange(layer, out) {
+  // OpenLayers zoom levels are one above the sMap map's (256 against 512 px tiles).
+  if (layer && typeof layer.getMinZoom === 'function') {
+    const min = layer.getMinZoom();
+    const max = layer.getMaxZoom();
+    if (isFinite(min) && min > -Infinity) { out.minzoom = Math.max(0, min - 1); }
+    if (isFinite(max) && max < Infinity) { out.maxzoom = Math.max(0, max - 1); }
+  }
+  return out;
+}
+
+function need(smap, name) {
+  if (typeof smap[name] !== 'function') { throw new Error('sMap: this needs @superrouteca/smap 1.1.0 (' + name + ')'); }
+}
+
+/** What kind of OpenLayers source this is, by what it can do (works across copies of OpenLayers). */
+export function sourceKind(source) {
+  if (!source) { return null; }
+  if (typeof source.getParams === 'function') { return 'wms'; }
+  if (typeof source.getMatrixSet === 'function' && typeof source.getRequestEncoding === 'function') { return 'wmts'; }
+  if (typeof source.getSourceTiles === 'function' || typeof source.getFeaturesInExtent === 'function' && typeof source.getTileGrid === 'function') { return 'vectortile'; }
+  if (typeof source.getFeatures === 'function' && typeof source.addFeature === 'function') { return 'vector'; }
+  if (typeof source.getUrls === 'function' && typeof source.getTileGrid === 'function') { return 'xyz'; }
+  return null;
+}
+
+/** A WMTS source as an XYZ template when its matrix set is Web Mercator with matrices by zoom; null otherwise. */
+export function wmtsTemplate(source) {
+  const grid = source.getTileGrid && source.getTileGrid();
+  const ids = grid && grid.getMatrixIds ? grid.getMatrixIds() : null;
+  const proj = source.getProjection && source.getProjection();
+  const code = proj && proj.getCode ? proj.getCode() : '';
+  if (!ids || !ids.length || !/3857|900913|GoogleMapsCompatible/i.test(code + ' ' + source.getMatrixSet())) { return null; }
+  // Matrix ids are the zoom, perhaps after a common prefix ("EPSG:3857:5").
+  const m = /^(.*?)(\d+)$/.exec(ids[0]);
+  if (!m) { return null; }
+  const prefix = m[1];
+  const zoom0 = parseInt(m[2], 10);
+  const byZoom = ids.every(function (id, i) { return id === prefix + (zoom0 + i); });
+  if (!byZoom || zoom0 !== 0) { return null; }
+  const dims = source.getDimensions ? source.getDimensions() : {};
+  const style = source.getStyle ? source.getStyle() : '';
+  const urls = source.getUrls() || [];
+  if (!urls.length) { return null; }
+  const tm = prefix + '{z}';
+  if (source.getRequestEncoding() === 'REST') {
+    return urls.map(function (u) {
+      let t = u.replace(/\{Layer\}/g, source.getLayer()).replace(/\{TileMatrixSet\}/g, source.getMatrixSet()).replace(/\{Style\}/g, style)
+        .replace(/\{TileMatrix\}/g, tm).replace(/\{TileRow\}/g, '{y}').replace(/\{TileCol\}/g, '{x}');
+      Object.keys(dims).forEach(function (k) { t = t.replace(new RegExp('\\{' + k + '\\}', 'g'), String(dims[k])); });
+      return t;
+    });
+  }
+  return urls.map(function (u) {
+    const q = ['SERVICE=WMTS', 'REQUEST=GetTile', 'VERSION=' + (source.getVersion ? source.getVersion() : '1.0.0'),
+      'LAYER=' + encodeURIComponent(source.getLayer()), 'STYLE=' + encodeURIComponent(style), 'FORMAT=' + encodeURIComponent(source.getFormat()),
+      'TILEMATRIXSET=' + encodeURIComponent(source.getMatrixSet()), 'TILEMATRIX=' + tm, 'TILEROW={y}', 'TILECOL={x}'];
+    Object.keys(dims).forEach(function (k) { q.push(encodeURIComponent(k) + '=' + encodeURIComponent(dims[k])); });
+    return u + (u.indexOf('?') >= 0 ? '&' : '?') + q.join('&');
+  });
+}
+
+function colorOf(c) {
+  if (c == null) { return undefined; }
+  if (Array.isArray(c)) { return 'rgba(' + c[0] + ', ' + c[1] + ', ' + c[2] + ', ' + (c[3] === undefined ? 1 : c[3]) + ')'; }
+  return typeof c === 'string' ? c : undefined;
+}
+
+/** A layer's fixed OpenLayers Style (not a function) as sMap point, line and area options. */
+export function styleOptions(style) {
+  const s = Array.isArray(style) ? style[0] : style;
+  if (!s || typeof s === 'function' || typeof s.getFill !== 'function') { return {}; }
+  const fill = s.getFill() && colorOf(s.getFill().getColor());
+  const stroke = s.getStroke();
+  const strokeColor = stroke && colorOf(stroke.getColor());
+  const strokeWidth = stroke && stroke.getWidth();
+  const image = s.getImage && s.getImage();
+  const out = { points: {}, lines: {}, polygons: {} };
+  if (strokeColor) { out.lines.color = strokeColor; out.polygons.outline = strokeColor; }
+  if (strokeWidth) { out.lines.width = strokeWidth; out.polygons.outlineWidth = strokeWidth; }
+  if (stroke && stroke.getLineDash && stroke.getLineDash() && strokeWidth) { out.lines.dash = stroke.getLineDash().map(function (d) { return d / strokeWidth; }); }
+  if (fill) { out.polygons.fill = fill; out.polygons.opacity = 1; }
+  if (image && typeof image.getRadius === 'function') {
+    out.points.radius = image.getRadius();
+    const f = image.getFill && image.getFill();
+    const st = image.getStroke && image.getStroke();
+    if (f) { out.points.color = colorOf(f.getColor()); }
+    if (st) { out.points.strokeColor = colorOf(st.getColor()); out.points.strokeWidth = st.getWidth(); }
+  } else if (image && typeof image.getSrc === 'function' && image.getSrc()) {
+    out.points.icon = image.getSrc();
+    if (image.getScale) { out.points.iconSize = image.getScale(); }
+  }
+  return out;
+}
+
+function geometryKind(type) {
+  if (type === 'Point' || type === 'MultiPoint') { return 'points'; }
+  if (type === 'LineString' || type === 'MultiLineString') { return 'lines'; }
+  return 'polygons';
+}
+
+/**
+ * Adds an OpenLayers layer or source to an sMap map; resolves to the ids it added (one per kind of geometry for a
+ * vector source: `<id>`, `<id>:lines`, `<id>:areas`, as addData names them).
+ *
+ * @param {Object} smap        an sMap map (after `await map.ready`)
+ * @param {string} id
+ * @param {Object} layerOrSource  an OpenLayers layer (its source, opacity and zoom range are used) or source
+ * @param {Object} [options]   slot, before, zIndex; `layers` (Style Specification layers) for a vector tile source;
+ *                             `projection` of a vector source's features (default the source's, else EPSG:3857);
+ *                             `GeoJSON` (ol/format/GeoJSON) to write them; and sMap layer options for features
+ */
+export async function addOpenLayersLayer(smap, id, layerOrSource, options) {
+  const o = Object.assign({}, options);
+  const isLayer = layerOrSource && typeof layerOrSource.getSource === 'function' && typeof layerOrSource.getOpacity === 'function';
+  const layer = isLayer ? layerOrSource : null;
+  const source = isLayer ? layerOrSource.getSource() : layerOrSource;
+  const kind = sourceKind(source);
+  const place = placement(o);
+  const credit = attributionOf(source);
+  const opacity = layer && layer.getOpacity() !== 1 ? layer.getOpacity() : undefined;
+  const common = zoomRange(layer, Object.assign({}, place));
+  if (credit) { common.attribution = credit; }
+  if (opacity !== undefined) { common.opacity = opacity; }
+
+  if (kind === 'wms') {
+    need(smap, 'addWmsLayer');
+    const p = Object.assign({}, source.getParams());
+    const url = (source.getUrls && source.getUrls() && source.getUrls()[0]) || (source.getUrl && source.getUrl());
+    const spec = Object.assign({}, common, { url: url, layers: p.LAYERS });
+    if (p.STYLES !== undefined) { spec.styles = p.STYLES; }
+    if (p.FORMAT !== undefined) { spec.format = p.FORMAT; }
+    if (p.TRANSPARENT !== undefined) { spec.transparent = String(p.TRANSPARENT) !== 'false'; }
+    if (p.VERSION === '1.1.1' || p.VERSION === '1.3.0') { spec.version = p.VERSION; }
+    const extra = {};
+    Object.keys(p).forEach(function (k) { if (['LAYERS', 'STYLES', 'FORMAT', 'TRANSPARENT', 'VERSION'].indexOf(k) < 0) { extra[k] = p[k]; } });
+    if (Object.keys(extra).length) { spec.params = extra; }
+    smap.addWmsLayer(id, spec);
+    return [id];
+  }
+  if (kind === 'wmts') {
+    const tiles = wmtsTemplate(source);
+    if (tiles) {
+      need(smap, 'addRasterLayer');
+      const grid = source.getTileGrid();
+      const size = grid.getTileSize(0);
+      smap.addRasterLayer(id, Object.assign({}, common, { tiles: tiles, tileSize: Array.isArray(size) ? size[0] : size }));
+      return [id];
+    }
+    need(smap, 'addWmtsLayer');
+    const urls = source.getUrls() || [];
+    await smap.addWmtsLayer(id, Object.assign({}, common, {
+      url: urls[0], layer: source.getLayer(), tileMatrixSet: source.getMatrixSet(), style: source.getStyle(), format: source.getFormat(),
+      encoding: source.getRequestEncoding() === 'REST' ? 'rest' : 'kvp',
+    }));
+    return [id];
+  }
+  if (kind === 'vectortile') {
+    need(smap, 'addVectorTiles');
+    if (!Array.isArray(o.layers) || !o.layers.length) {
+      throw new Error('sMap: a vector tile source needs `layers` (Style Specification layers): OpenLayers style functions have no counterpart');
+    }
+    const spec = Object.assign({}, place, { tiles: expandTemplates(source.getUrls() || []), layers: o.layers });
+    if (credit) { spec.attribution = credit; }
+    if (common.minzoom !== undefined) { spec.minzoom = common.minzoom; }
+    if (common.maxzoom !== undefined) { spec.maxzoom = common.maxzoom; }
+    smap.addVectorTiles(id, spec);
+    return [id];
+  }
+  if (kind === 'xyz') {
+    need(smap, 'addRasterLayer');
+    const raw = source.getUrls() || [];
+    if (!raw.length) { throw new Error('sMap: this tile source has no URL template'); }
+    const grid = source.getTileGrid();
+    const size = grid ? grid.getTileSize(0) : 256;
+    const spec = Object.assign({}, common, { tiles: expandTemplates(raw), tileSize: Array.isArray(size) ? size[0] : size });
+    if (raw.some(function (u) { return u.indexOf('{-y}') >= 0; })) { spec.scheme = 'tms'; }
+    smap.addRasterLayer(id, spec);
+    return [id];
+  }
+  if (kind === 'vector') {
+    const GeoJSONFormat = o.GeoJSON || (await import('ol/format/GeoJSON.js')).default;
+    const projection = o.projection || (source.getProjection && source.getProjection()) || 'EPSG:3857';
+    const fc = new GeoJSONFormat().writeFeaturesObject(source.getFeatures(), { featureProjection: projection, dataProjection: 'EPSG:4326' });
+    const look = layer && typeof layer.getStyle === 'function' ? styleOptions(layer.getStyle()) : {};
+    const layerOptions = pick(o, ['layers', 'projection', 'GeoJSON', 'slot', 'before', 'zIndex']);
+    const kinds = { points: [], lines: [], polygons: [] };
+    fc.features.forEach(function (f) { if (f.geometry) { kinds[geometryKind(f.geometry.type)].push(f); } });
+    const ids = [];
+    const names = { points: id, lines: id + ':lines', polygons: id + ':areas' };
+    const calls = { points: 'addPoints', lines: 'addLines', polygons: 'addPolygons' };
+    Object.keys(kinds).forEach(function (k) {
+      if (!kinds[k].length) { return; }
+      smap[calls[k]](names[k], { type: 'FeatureCollection', features: kinds[k] }, Object.assign({}, look[k] || {}, layerOptions, place));
+      ids.push(names[k]);
+    });
+    return ids;
+  }
+  throw new Error('sMap: this OpenLayers source has no counterpart on an sMap map (XYZ, OSM, TileJSON, TileWMS, ImageWMS, WMTS, VectorTile and Vector sources are)');
+}
+
+function pick(o, skip) {
+  const out = {};
+  Object.keys(o || {}).forEach(function (k) { if (skip.indexOf(k) < 0) { out[k] = o[k]; } });
+  return out;
+}
+
+/**
+ * Adds every layer of an OpenLayers map (or a list of layers) to an sMap map, in their order, as `<prefix><n>`;
+ * resolves to { added: [ids], skipped: [{ index, reason }] }.
+ */
+export async function addOpenLayersLayers(smap, layers, options) {
+  const o = Object.assign({ prefix: 'ol-' }, options);
+  const list = layers && typeof layers.getLayers === 'function' ? layers.getLayers().getArray() : (layers && layers.getArray ? layers.getArray() : layers || []);
+  const added = [];
+  const skipped = [];
+  for (let i = 0; i < list.length; i++) {
+    const l = list[i];
+    if (typeof l.getLayers === 'function' && !l.getSource) {
+      const inner = await addOpenLayersLayers(smap, l, Object.assign({}, o, { prefix: o.prefix + i + '-' }));
+      added.push.apply(added, inner.added);
+      skipped.push.apply(skipped, inner.skipped);
+      continue;
+    }
+    // An sMap basemap already in the OpenLayers map is the sMap map itself.
+    if (typeof l.getSMap === 'function' || (l.get && l.get('smap:skip'))) { continue; }
+    try { added.push.apply(added, await addOpenLayersLayer(smap, o.prefix + i, l, o.layerOptions && o.layerOptions[i])); }
+    catch (e) { skipped.push({ index: i, reason: e.message }); }
+  }
+  return { added: added, skipped: skipped };
+}

package/types/index.d.ts

@@ -0,0 +1,183 @@
+// Types of @superrouteca/smap-openlayers.
+import Layer from 'ol/layer/Layer.js';
+import TileLayer from 'ol/layer/Tile.js';
+import XYZ from 'ol/source/XYZ.js';
+import Control from 'ol/control/Control.js';
+import type { Options as XYZOptions } from 'ol/source/XYZ.js';
+import type { Map as SMapMap, MapOptions as SMapMapOptions, StyleFlavor } from '@superrouteca/smap';
+import type SMapClient from '@superrouteca/smap/client';
+
+export type { StyleFlavor };
+/** A colour scheme or a saved custom style (`custom:<id>`). */
+export type SMapStyle = StyleFlavor | `custom:${string}`;
+
+/** How the adapters reach the service: a map key or a token (renewed through getToken), the nearest node. */
+export interface AccessOptions {
+  /** The map service, `https://tile.srsr.ca` by default. */
+  baseUrl?: string;
+  /** A map key (`smk_…`) whose allowlist names this site. */
+  apiKey?: string;
+  token?: string;
+  /** Called at start and again two minutes before each token expires. */
+  getToken?: () => string | Promise<string>;
+  /** Node URLs known in advance, used while `baseUrl` is down. */
+  nodes?: string[];
+  /** Read from the nearest node (default true). */
+  nearest?: boolean;
+  fetch?: typeof fetch;
+  timeoutMs?: number;
+  /** A JS client of your own instead of the options above. */
+  client?: SMapClient;
+}
+
+/** The service access the raster layer uses (token, node order, failover). */
+export declare class SMapAccess {
+  constructor(options?: AccessOptions);
+  readonly client: SMapClient;
+  readonly baseUrl: string;
+  start(): Promise<this>;
+  refresh(): Promise<string | null>;
+  token(): string | null;
+  nodes(): string[];
+  head(): string;
+  isOurs(url: string): boolean;
+  headers(url: string): Record<string, string>;
+  rewrite(url: string): string;
+  failed(url: string): void;
+  withKey(path: string): string;
+  style(style: SMapStyle, language?: string): Promise<Record<string, unknown>>;
+  rasterTile(style: SMapStyle, z: number, x: number, y: number, options?: { lang?: string; retina?: boolean }): Promise<Blob>;
+  rasterTemplate(style: SMapStyle, options?: { lang?: string; retina?: boolean }): string;
+  on(listener: (type: 'token' | 'nodes', value: unknown) => void): this;
+  stop(): void;
+}
+
+export interface SMapLayerOptions extends Omit<SMapMapOptions, 'container' | 'style'> {
+  /** A colour scheme, `custom:<id>`, or a style URL or object of your own. */
+  style?: SMapStyle | string | Record<string, unknown>;
+  /** OpenLayers' clicks and pointer moves reach sMap's layers (popups, Auto Zoom, onClick, hover); default true. */
+  interactive?: boolean;
+  /** The sMap Web SDK module to use (default the installed `@superrouteca/smap`). */
+  sdk?: unknown;
+  className?: string;
+  opacity?: number;
+  visible?: boolean;
+  extent?: number[];
+  zIndex?: number;
+  minResolution?: number;
+  maxResolution?: number;
+  minZoom?: number;
+  maxZoom?: number;
+  properties?: Record<string, unknown>;
+}
+
+/** The sMap vector map as an OpenLayers layer (Web Mercator views). The sMap map's calls are forwarded once it is ready. */
+export declare class SMapLayer extends Layer {
+  constructor(options?: SMapLayerOptions);
+  /** Resolves to the sMap map once it is ready. */
+  readonly ready: Promise<SMapMap>;
+  /** The sMap map, or null before it is ready. */
+  getSMap(): SMapMap | null;
+  /** An sMap map call whose answer is a value (e.g. `call('basemap')`, `call('toJSON')`). */
+  call<T = unknown>(name: string, ...args: unknown[]): Promise<T>;
+  setStyle(style: SMapStyle | string | Record<string, unknown>): this;
+  setLanguage(language: string): this;
+  setBasemap(overrides: Record<string, Record<string, unknown>>): this;
+  setAutoZoom(on: boolean): this;
+  addPoints(id: string, data: unknown, options?: Record<string, unknown>): this;
+  addLines(id: string, data: unknown, options?: Record<string, unknown>): this;
+  addPolygons(id: string, data: unknown, options?: Record<string, unknown>): this;
+  addData(id: string, input: unknown, options?: Record<string, unknown>): this;
+  setData(id: string, data: unknown): this;
+  /** The sMap map's setVisible (the layer's own setVisible stays OpenLayers'). */
+  setSMapVisible(id: string, visible: boolean): this;
+  fitLayer(id: string, options?: Record<string, unknown>): this;
+  openPopup(lngLat: [number, number] | { lng: number; lat: number }, content: unknown, options?: Record<string, unknown>): this;
+  closePopup(): this;
+  setBuildings3D(on: boolean, options?: { color?: string; opacity?: number }): this;
+  addSource(id: string, source: Record<string, unknown>): this;
+  removeSource(id: string): this;
+  addStyleLayer(layer: Record<string, unknown>, options?: { before?: string; slot?: 'bottom' | 'roads' | 'labels' | 'top' }): this;
+  setPaint(layerId: string, name: string, value: unknown): this;
+  setLayout(layerId: string, name: string, value: unknown): this;
+  setFilter(layerId: string, filter: unknown): this;
+  addRasterLayer(id: string, options: Record<string, unknown>): this;
+  addWmsLayer(id: string, options: Record<string, unknown>): this;
+  addWmtsLayer(id: string, options: Record<string, unknown>): this;
+  addVectorTiles(id: string, options: Record<string, unknown>): this;
+  addArcGisLayer(id: string, options: Record<string, unknown>): this;
+  loadLayers(json: unknown): this;
+  /** Removes one of the sMap map's layers. */
+  removeSMapLayer(id: string): this;
+}
+
+export interface SMapRasterSourceOptions extends AccessOptions, Omit<XYZOptions, 'url' | 'urls' | 'tileSize' | 'tilePixelRatio' | 'tileLoadFunction'> {
+  style?: SMapStyle;
+  language?: string;
+  /** 512 px tiles for high-density screens (default: the screen's pixel ratio above 1). */
+  retina?: boolean;
+  /** An access of your own, shared between sources. */
+  access?: SMapAccess;
+}
+
+/** sMap raster tiles as an OpenLayers XYZ source. */
+export declare class SMapRasterSource extends XYZ {
+  constructor(options?: SMapRasterSourceOptions);
+  setStyle(style: SMapStyle): this;
+  setLanguage(language: string): this;
+  getAccess(): SMapAccess;
+}
+
+export interface SMapRasterLayerOptions extends SMapRasterSourceOptions {
+  source?: SMapRasterSource;
+  className?: string;
+  opacity?: number;
+  visible?: boolean;
+  zIndex?: number;
+  minZoom?: number;
+  maxZoom?: number;
+  preload?: number;
+}
+
+/** sMap raster tiles as an OpenLayers tile layer, with the sMap badge. */
+export declare class SMapRasterLayer extends TileLayer<SMapRasterSource> {
+  constructor(options?: SMapRasterLayerOptions);
+}
+
+/** The sMap badge as an OpenLayers control. */
+export declare class SMapBadge extends Control {
+  constructor(options?: { document?: Document });
+}
+
+export declare function smapLayer(options?: SMapLayerOptions): SMapLayer;
+export declare function smapRasterSource(options?: SMapRasterSourceOptions): SMapRasterSource;
+export declare function smapRasterLayer(options?: SMapRasterLayerOptions): SMapRasterLayer;
+/** The vector map where WebGL 2 exists, raster tiles elsewhere (`mode`, default `auto`). */
+export declare function smapBasemap(options?: (SMapLayerOptions & SMapRasterLayerOptions) & { mode?: 'auto' | 'vector' | 'raster' }): SMapLayer | SMapRasterLayer;
+export declare function hasWebGL2(doc?: Document): boolean;
+export declare function checkStyle(style?: string): SMapStyle;
+export declare function rasterPath(style: SMapStyle, z: number, x: number, y: number, options?: { lang?: string; retina?: boolean }): string;
+export declare function stylePath(style: SMapStyle, lang?: string): string;
+export declare const styles: StyleFlavor[];
+export declare const version: string;
+export declare const DEFAULT_BASE: string;
+export declare const OSM_ATTRIBUTION: string;
+export declare const FORWARDED: string[];
+
+declare const SMapOpenLayers: {
+  version: string;
+  styles: StyleFlavor[];
+  SMapLayer: typeof SMapLayer;
+  smapLayer: typeof smapLayer;
+  SMapRasterSource: typeof SMapRasterSource;
+  smapRasterSource: typeof smapRasterSource;
+  SMapRasterLayer: typeof SMapRasterLayer;
+  smapRasterLayer: typeof smapRasterLayer;
+  smapBasemap: typeof smapBasemap;
+  SMapBadge: typeof SMapBadge;
+  SMapAccess: typeof SMapAccess;
+  hasWebGL2: typeof hasWebGL2;
+  rasterPath: typeof rasterPath;
+  checkStyle: typeof checkStyle;
+};
+export default SMapOpenLayers;

package/types/on-smap.d.ts

@@ -0,0 +1,31 @@
+// Types of @superrouteca/smap-openlayers/on-smap: OpenLayers sources and layers on an sMap map.
+import type BaseLayer from 'ol/layer/Base.js';
+import type Source from 'ol/source/Source.js';
+import type OlMap from 'ol/Map.js';
+import type LayerGroup from 'ol/layer/Group.js';
+import type { Map as SMapMap, StyleLayer, Slot } from '@superrouteca/smap';
+
+export interface AddOptions {
+  slot?: Slot;
+  before?: string;
+  zIndex?: number;
+  /** Style Specification layers drawing a vector tile source. */
+  layers?: StyleLayer[];
+  /** The projection of a vector source's features (default the source's, else EPSG:3857). */
+  projection?: string;
+  /** ol/format/GeoJSON, when it should not be imported on demand. */
+  GeoJSON?: new () => { writeFeaturesObject(features: unknown[], options?: unknown): { type: 'FeatureCollection'; features: any[] } };
+  /** sMap layer options for a vector source's features (popup, marker, color, …). */
+  [smapOption: string]: unknown;
+}
+
+export type SourceKind = 'xyz' | 'wms' | 'wmts' | 'vectortile' | 'vector';
+
+/** Adds an OpenLayers layer or source to an sMap map; resolves to the ids added. */
+export declare function addOpenLayersLayer(smap: SMapMap, id: string, layerOrSource: BaseLayer | Source, options?: AddOptions): Promise<string[]>;
+/** Adds every layer of an OpenLayers map, group or list, in order, as `<prefix><n>`. */
+export declare function addOpenLayersLayers(smap: SMapMap, layers: OlMap | LayerGroup | BaseLayer[], options?: { prefix?: string; layerOptions?: Record<number, AddOptions> }): Promise<{ added: string[]; skipped: Array<{ index: number; reason: string }> }>;
+export declare function sourceKind(source: unknown): SourceKind | null;
+export declare function expandTemplates(urls: string[]): string[];
+export declare function wmtsTemplate(source: unknown): string[] | null;
+export declare function styleOptions(style: unknown): { points?: Record<string, unknown>; lines?: Record<string, unknown>; polygons?: Record<string, unknown> };