@elastic/ems-client 7.17.1 → 7.17.2

package/CHANGELOG.md

@@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [7.17.2] - 2024-07-05
+
+## Changed
+
+- Update dependencies  #218 #219 #220 #221 #236 #237
+
 ## [7.17.1] - 2023-11-09
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elastic/ems-client",
-  "version": "7.17.1",
+  "version": "7.17.2",
   "description": "JavaScript client library for the Elastic Maps Service",
   "main": "target/node/index.js",
   "browser": "target/web/index.js",
@@ -35,13 +35,13 @@
     }
   },
   "dependencies": {
-    "@types/geojson": "^7946.0.10",
+    "@types/geojson": "^7946.0.14",
     "@types/lru-cache": "^5.1.0",
-    "@types/topojson-client": "^3.1.1",
-    "@types/topojson-specification": "^1.0.1",
+    "@types/topojson-client": "^3.1.4",
+    "@types/topojson-specification": "^1.0.5",
     "lodash": "^4.17.15",
     "lru-cache": "^6.0.0",
-    "semver": "7.5.4",
+    "semver": "7.6.2",
     "topojson-client": "^3.1.0"
   },
   "devDependencies": {
@@ -51,7 +51,7 @@
     "@babel/preset-env": "^7.5.5",
     "@babel/preset-typescript": "^7.9.0",
     "@types/jest": "^26.0.10",
-    "@types/lodash": "^4.14.150",
+    "@types/lodash": "4.17.5",
     "@types/node": "^13.13.5",
     "@types/node-fetch": "^2.5.7",
     "@types/semver": "^7.1.0",

package/target/ems_client.d.ts

@@ -1,10 +1,10 @@
 import { TMSService } from './tms_service';
 import { EMSFormatType, FileLayer } from './file_layer';
 import { FeatureCollection } from 'geojson';
-declare type LocalizedStrings = {
+type LocalizedStrings = {
     [key: string]: string;
 };
-declare type BaseClientConfig = {
+type BaseClientConfig = {
     appName?: string;
     manifestServiceUrl?: string;
     tileApiUrl: string;
@@ -17,35 +17,35 @@ declare type BaseClientConfig = {
     proxyPath?: string;
     cacheSize?: number;
 };
-declare type DeprecatedClientConfig = BaseClientConfig & {
+type DeprecatedClientConfig = BaseClientConfig & {
     kbnVersion: string;
 };
-declare type ClientConfig = BaseClientConfig & {
+type ClientConfig = BaseClientConfig & {
     appVersion: string;
 };
-declare type EmsCatalogService = {
+type EmsCatalogService = {
     id?: string;
     name?: string;
     manifest: string;
     type: string;
 };
-declare type EmsCatalogManifest = {
+type EmsCatalogManifest = {
     version?: string;
     services: EmsCatalogService[];
 };
-declare type EmsTmsCatalog = {
+type EmsTmsCatalog = {
     version?: string;
     services: TMSServiceConfig[];
 };
-export declare type EmsTmsFormat = {
+export type EmsTmsFormat = {
     locale: string;
     format: string;
     url: string;
 };
-export declare type BaseEmsServiceConfig = {
+export type BaseEmsServiceConfig = {
     attribution: EmsLayerAttribution[];
 };
-export declare type FileLayerConfig = BaseEmsServiceConfig & {
+export type FileLayerConfig = BaseEmsServiceConfig & {
     layer_id: string;
     created_at: string;
     formats: (EmsFileLayerFormatGeoJson | EmsFileLayerFormatTopoJson)[];
@@ -53,7 +53,7 @@ export declare type FileLayerConfig = BaseEmsServiceConfig & {
     legacy_ids: string[];
     layer_name: LocalizedStrings;
 };
-export declare type FileLayerField = {
+export type FileLayerField = {
     type: string;
     id: string;
     label: LocalizedStrings;
@@ -61,27 +61,27 @@ export declare type FileLayerField = {
     regex?: string;
     alias?: string[];
 };
-export declare type TMSServiceConfig = BaseEmsServiceConfig & {
+export type TMSServiceConfig = BaseEmsServiceConfig & {
     id: string;
     name: {
         en: string;
     };
     formats: EmsTmsFormat[];
 };
-declare type EmsFileCatalog = {
+type EmsFileCatalog = {
     version?: string;
     layers: FileLayerConfig[];
 };
-export declare type EmsLayerAttribution = {
+export type EmsLayerAttribution = {
     label: LocalizedStrings;
     url: LocalizedStrings;
 };
-export declare type EmsFileLayerFormatGeoJson = {
+export type EmsFileLayerFormatGeoJson = {
     type: EMSFormatType.geojson;
     url: string;
     legacy_default: boolean;
 };
-export declare type EmsFileLayerFormatTopoJson = {
+export type EmsFileLayerFormatTopoJson = {
     type: EMSFormatType.topojson;
     url: string;
     legacy_default: boolean;

package/target/ems_client.js

@@ -0,0 +1,318 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMSClient = exports.LATEST_API_URL_PATH = void 0;
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+const lodash_1 = __importDefault(require("lodash"));
+const tms_service_1 = require("./tms_service");
+const file_layer_1 = require("./file_layer");
+const coerce_1 = __importDefault(require("semver/functions/coerce"));
+const valid_1 = __importDefault(require("semver/functions/valid"));
+const major_1 = __importDefault(require("semver/functions/major"));
+const minor_1 = __importDefault(require("semver/functions/minor"));
+const url_1 = require("url");
+const utils_1 = require("./utils");
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const REST_API_REGEX = /\d{4}-\d{2}-\d{2}/;
+exports.LATEST_API_URL_PATH = 'latest';
+/**
+ * plugins cannot have upstream dependencies on core/*-kibana.
+ * Work-around by copy-pasting modifyUrl routine here.
+ * @param url
+ * @param block
+ */
+function modifyUrlLocal(url, block) {
+    const parsed = (0, url_1.parse)(url, true);
+    // copy over the most specific version of each
+    // property. By default, the parsed url includes
+    // several conflicting properties (like path and
+    // pathname + search, or search and query) and keeping
+    // track of which property is actually used when they
+    // are formatted is harder than necessary
+    const meaningfulParts = {
+        protocol: parsed.protocol,
+        slashes: parsed.slashes,
+        auth: parsed.auth,
+        hostname: parsed.hostname,
+        port: parsed.port,
+        pathname: parsed.pathname,
+        query: parsed.query || {},
+        hash: parsed.hash,
+    };
+    // the block modifies the meaningfulParts object, or returns a new one
+    const modifiedParts = block(meaningfulParts) || meaningfulParts;
+    // format the modified/replaced meaningfulParts back into a url
+    return (0, url_1.format)({
+        protocol: modifiedParts.protocol,
+        slashes: modifiedParts.slashes,
+        auth: modifiedParts.auth,
+        hostname: modifiedParts.hostname,
+        port: modifiedParts.port,
+        pathname: modifiedParts.pathname,
+        query: modifiedParts.query,
+        hash: modifiedParts.hash,
+    });
+}
+const extendUrl = (url, props) => modifyUrlLocal(url, (parsed) => lodash_1.default.merge(parsed, props));
+/**
+ *  Unescape a url template that was escaped by encodeURI() so leaflet
+ *  will be able to correctly locate the variables in the template
+ *  @param  {String} url
+ *  @return {String}
+ */
+const unescapeTemplateVars = (url) => {
+    const ENCODED_TEMPLATE_VARS_RE = /%7B(\w+?)%7D/g;
+    return url.replace(ENCODED_TEMPLATE_VARS_RE, (total, varName) => `{${varName}}`);
+};
+//this is not the default locale from Kibana, but the default locale supported by the Elastic Maps Service
+const DEFAULT_LANGUAGE = 'en';
+class EMSClient {
+    constructor(config) {
+        this.EMS_LOAD_TIMEOUT = 32000;
+        this._isRestApi = false;
+        // Remove kbnVersion in 8.0
+        if ('kbnVersion' in config) {
+            console.warn('The "kbnVersion" parameter for ems-client is deprecated. Please use "appVersion" instead.');
+            this._appVersion = config.kbnVersion;
+        }
+        else {
+            this._appVersion = config.appVersion;
+        }
+        this._queryParams = {
+            elastic_tile_service_tos: 'agree',
+            my_app_name: config.appName || 'kibana',
+            my_app_version: this._appVersion,
+        };
+        this._sanitizer = config.htmlSanitizer ? config.htmlSanitizer : (x) => x;
+        this._tileApiUrl = config.tileApiUrl;
+        this._fileApiUrl = config.fileApiUrl;
+        this._emsVersion = this._getEmsVersion(config.emsVersion);
+        this._isRestApi = this._emsVersion == config.emsVersion;
+        this._emsLandingPageUrl = config.landingPageUrl || '';
+        this._language = config.language || DEFAULT_LANGUAGE;
+        this._fetchFunction = config.fetchFunction;
+        this._proxyPath = config.proxyPath || '';
+        this._cache = new lru_cache_1.default({
+            max: config.cacheSize || 10,
+        });
+        this._invalidateSettings();
+    }
+    getDefaultLocale() {
+        return DEFAULT_LANGUAGE;
+    }
+    getLocale() {
+        return this._language;
+    }
+    getValueInLanguage(i18nObject) {
+        if (!i18nObject) {
+            return '';
+        }
+        return i18nObject[this._language] ? i18nObject[this._language] : i18nObject[DEFAULT_LANGUAGE];
+    }
+    /**
+     * this internal method is overridden by the tests to simulate custom manifest.
+     */
+    getManifest(endpointUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = extendUrl(endpointUrl, { query: this._queryParams });
+                const response = yield this._fetchWithTimeout(url);
+                if (!response.ok) {
+                    throw new Error(response.statusText);
+                }
+                if (response) {
+                    return (yield response.json());
+                }
+                else {
+                    throw new Error('Response not found');
+                }
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    throw e;
+                }
+                else {
+                    throw new Error('Unknown error');
+                }
+            }
+        });
+    }
+    /**
+     * Add optional query-parameters to all requests
+     *
+     * @param additionalQueryParams
+     */
+    addQueryParams(additionalQueryParams) {
+        for (const key in additionalQueryParams) {
+            if (Object.prototype.hasOwnProperty.call(additionalQueryParams, key)) {
+                if (additionalQueryParams[key] !== this._queryParams[key]) {
+                    //changes detected.
+                    this._queryParams = lodash_1.default.assign({}, this._queryParams, additionalQueryParams);
+                    this._invalidateSettings();
+                    break;
+                }
+            }
+        }
+    }
+    getMainManifest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getMainCatalog();
+        });
+    }
+    getDefaultFileManifest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getDefaultFileCatalog();
+        });
+    }
+    getDefaultTMSManifest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getDefaultTMSCatalog();
+        });
+    }
+    getFileLayers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._loadFileLayers();
+        });
+    }
+    getTMSServices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._loadTMSServices();
+        });
+    }
+    cacheGeoJson(layerId, geoJson) {
+        this._cache.set(layerId, geoJson);
+        return;
+    }
+    getCachedGeoJson(layerId) {
+        return this._cache.get(layerId);
+    }
+    getEmsVersion() {
+        return this._emsVersion;
+    }
+    getTileApiUrl() {
+        return this._tileApiUrl;
+    }
+    getFileApiUrl() {
+        return this._fileApiUrl;
+    }
+    getLandingPageUrl() {
+        return this._emsLandingPageUrl;
+    }
+    sanitizeHtml(html) {
+        return this._sanitizer(html);
+    }
+    extendUrlWithParams(url) {
+        return unescapeTemplateVars(extendUrl(url, {
+            query: this._queryParams,
+        }));
+    }
+    findFileLayerById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileLayers = yield this.getFileLayers();
+            for (let i = 0; i < fileLayers.length; i++) {
+                if (fileLayers[i].hasId(id)) {
+                    return fileLayers[i];
+                }
+            }
+        });
+    }
+    findTMSServiceById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tmsServices = yield this.getTMSServices();
+            for (let i = 0; i < tmsServices.length; i++) {
+                if (tmsServices[i].hasId(id)) {
+                    return tmsServices[i];
+                }
+            }
+        });
+    }
+    _getEmsVersion(version) {
+        if (version === null || version === void 0 ? void 0 : version.match(REST_API_REGEX)) {
+            return version;
+        }
+        const semverVersion = (0, valid_1.default)((0, coerce_1.default)(version));
+        if (semverVersion) {
+            return `v${(0, major_1.default)(semverVersion)}.${(0, minor_1.default)(semverVersion)}`;
+        }
+        else {
+            throw new Error(`Invalid version: ${version}`);
+        }
+    }
+    _fetchWithTimeout(url) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`Request to ${url} timed out`)), this.EMS_LOAD_TIMEOUT);
+            this._fetchFunction(url).then((response) => {
+                clearTimeout(timer);
+                resolve(response);
+            }, (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
+    _invalidateSettings() {
+        this._cache.reset();
+        this._getMainCatalog = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            const services = [];
+            if (this._tileApiUrl) {
+                const version = this._isRestApi ? exports.LATEST_API_URL_PATH : this._emsVersion;
+                services.push({
+                    type: 'tms',
+                    manifest: (0, utils_1.toAbsoluteUrl)(this._tileApiUrl, `${version}/manifest`),
+                });
+            }
+            if (this._fileApiUrl) {
+                const version = this._isRestApi ? exports.LATEST_API_URL_PATH : this._emsVersion;
+                services.push({
+                    type: 'file',
+                    manifest: (0, utils_1.toAbsoluteUrl)(this._fileApiUrl, `${version}/manifest`),
+                });
+            }
+            return { services: services };
+        }));
+        this._getDefaultTMSCatalog = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            const catalogue = yield this._getMainCatalog();
+            const firstService = catalogue.services.find((service) => service.type === 'tms');
+            if (!firstService) {
+                return { services: [] };
+            }
+            const url = this._proxyPath + firstService.manifest;
+            return yield this.getManifest(url);
+        }));
+        this._getDefaultFileCatalog = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            const catalogue = yield this._getMainCatalog();
+            const firstService = catalogue.services.find((service) => service.type === 'file');
+            if (!firstService) {
+                return { layers: [] };
+            }
+            const url = this._proxyPath + firstService.manifest;
+            return yield this.getManifest(url);
+        }));
+        //Cache the actual instances of TMSService as these in turn cache sub-manifests for the style-files
+        this._loadTMSServices = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            const tmsManifest = yield this._getDefaultTMSCatalog();
+            return tmsManifest.services.map((serviceConfig) => new tms_service_1.TMSService(serviceConfig, this, this._proxyPath));
+        }));
+        this._loadFileLayers = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            const fileManifest = yield this._getDefaultFileCatalog();
+            return fileManifest.layers.map((layerConfig) => new file_layer_1.FileLayer(layerConfig, this, this._proxyPath));
+        }));
+    }
+}
+exports.EMSClient = EMSClient;

package/target/ems_service.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractEmsService = void 0;
+const utils_1 = require("./utils");
+class AbstractEmsService {
+    constructor(config, emsClient, proxyPath) {
+        /**
+         * Checks if url is absolute. If not, prepend the basePath.
+         */
+        this._getAbsoluteUrl = (url) => {
+            if (/^https?:\/\//.test(url)) {
+                return url;
+            }
+            else {
+                return (0, utils_1.toAbsoluteUrl)(this.getApiUrl(), url);
+            }
+        };
+        this._config = config;
+        this._emsClient = emsClient;
+        this._proxyPath = proxyPath;
+    }
+    getAttributions() {
+        return this._config.attribution.map((attribution) => {
+            const url = this._emsClient.getValueInLanguage(attribution.url);
+            const label = this._emsClient.getValueInLanguage(attribution.label);
+            return {
+                url: url,
+                label: label,
+            };
+        });
+    }
+    getMarkdownAttribution() {
+        const attributions = this._config.attribution.map((attribution) => {
+            const url = this._emsClient.getValueInLanguage(attribution.url);
+            const label = this._emsClient.getValueInLanguage(attribution.label);
+            return `[${label}](${url})`;
+        });
+        return attributions.join('|');
+    }
+}
+exports.AbstractEmsService = AbstractEmsService;

package/target/file_layer.d.ts

@@ -5,7 +5,7 @@ export declare enum EMSFormatType {
     geojson = "geojson",
     topojson = "topojson"
 }
-export declare type EMSFormatTypeStrings = keyof typeof EMSFormatType;
+export type EMSFormatTypeStrings = keyof typeof EMSFormatType;
 export declare class FileLayer extends AbstractEmsService {
     protected readonly _config: FileLayerConfig;
     constructor(config: FileLayerConfig, emsClient: EMSClient, proxyPath: string);