@elastic/ems-client 8.5.0 → 8.5.2

package/target/tms_service.js

@@ -0,0 +1,409 @@
+"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.
+ */
+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.TMSService = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const ems_service_1 = require("./ems_service");
+const utils_1 = require("./utils");
+class TMSService extends ems_service_1.AbstractEmsService {
+    constructor(config, emsClient, proxyPath) {
+        super(config, emsClient, proxyPath);
+        this._getRasterStyleJson = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            const rasterUrl = this._getStyleUrlForLocale('raster');
+            if (rasterUrl) {
+                const url = this._proxyPath + this._getAbsoluteUrl(rasterUrl);
+                return this._emsClient.getManifest(this._emsClient.extendUrlWithParams(url));
+            }
+            else {
+                return;
+            }
+        }));
+        this._getVectorStyleJsonRaw = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            const vectorUrl = this._getStyleUrlForLocale('vector');
+            if (vectorUrl) {
+                const url = this._proxyPath + this._getAbsoluteUrl(vectorUrl);
+                const vectorJson = yield this._emsClient.getManifest(this._emsClient.extendUrlWithParams(url));
+                return Object.assign({}, vectorJson);
+            }
+            else {
+                return;
+            }
+        }));
+        this._getVectorStyleJsonInlined = lodash_1.default.once(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const vectorJson = yield this._getVectorStyleJsonRaw();
+            if (vectorJson) {
+                const inlinedSources = {};
+                const { sources } = vectorJson;
+                for (const sourceName of Object.getOwnPropertyNames(sources)) {
+                    const { url } = sources[sourceName];
+                    if (url) {
+                        const sourceUrl = this._proxyPath + this._getAbsoluteUrl(url);
+                        const extendedUrl = this._emsClient.extendUrlWithParams(sourceUrl);
+                        const sourceJson = yield this._emsClient.getManifest(extendedUrl);
+                        const tiles = (_a = sourceJson === null || sourceJson === void 0 ? void 0 : sourceJson.tiles) === null || _a === void 0 ? void 0 : _a.map((tileUrl) => {
+                            const directUrl = this._proxyPath + this._getAbsoluteUrl(tileUrl);
+                            return this._emsClient.extendUrlWithParams(directUrl);
+                        });
+                        inlinedSources[sourceName] = Object.assign(Object.assign({}, sourceJson), { type: 'vector', tiles });
+                    }
+                }
+                return Object.assign(Object.assign({}, vectorJson), { sources: inlinedSources, sprite: yield this._getSpriteSheetRootPath(), glyphs: yield this._getUrlTemplateForGlyphs() });
+            }
+            else {
+                return;
+            }
+        }));
+        this._config = config;
+    }
+    /*
+    This method returns an array of objects with the layers and the new
+    layout['text-field'] to apply using map.setLayoutProperty
+    */
+    static transformLanguageProperty(layer, lang) {
+        const supportedLang = this.SupportedLanguages.find((l) => l.key === lang);
+        if (layer.type === 'symbol' && layer.layout !== undefined && supportedLang !== undefined) {
+            const omtLang = supportedLang.omt;
+            const textField = layer.layout['text-field'];
+            if (textField && typeof textField === 'string') {
+                return TMSService._getTextField(textField, omtLang);
+            }
+        }
+        return;
+    }
+    /*
+    This method returns an array of objects per layer, containing a list of
+    properties with new colors to apply using map.setPaintProperty
+    */
+    static transformColorProperties(layer, color, operation, percentage) {
+        if (['background', 'fill', 'line', 'symbol'].indexOf(layer.type) !== -1 && layer.paint) {
+            const paint = layer.paint;
+            if (layer.type === 'symbol' && Object.keys(paint).length === 0) {
+                paint['text-color'] = 'rgb(0,0,0)';
+            }
+            const types = Object.keys(paint).filter((key) => {
+                return ([
+                    'background-color',
+                    'circle-color',
+                    'circle-stroke-color',
+                    'fill-color',
+                    'fill-extrusion-color',
+                    'fill-outline-color',
+                    'icon-color',
+                    'icon-halo-color',
+                    'line-color',
+                    'text-color',
+                    'text-halo-color',
+                ].indexOf(key) !== -1);
+            });
+            return types.map((type) => {
+                const paintColor = paint[type];
+                return {
+                    property: type,
+                    color: paintColor && color
+                        ? (0, utils_1.colorizeColor)(paintColor, color, operation, percentage)
+                        : paintColor,
+                };
+            });
+        }
+        else {
+            return [];
+        }
+    }
+    static _getTextField(label, lang) {
+        // Capture {name:xx} labels
+        const labelMatch = label.match(/\{name([:_])(.{2})\}/);
+        if (labelMatch && labelMatch[1] != lang) {
+            // Only apply if the languages are different
+            return ['coalesce', ['get', `name:${lang}`], ['get', `name${labelMatch[1]}${labelMatch[2]}`]];
+        }
+        else if (label.includes('latin') && label.includes('nonlatin')) {
+            // Capture the common pattern {name:latin}\n{name:nonlatin}
+            return [
+                'coalesce',
+                ['get', `name:${lang}`],
+                ['concat', ['get', 'name:latin'], '\n', ['get', 'name:nonlatin']],
+            ];
+        }
+        // If no case is found, return the input label
+        return label;
+    }
+    getDefaultRasterStyle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tileJson = yield this._getRasterStyleJson();
+            if (tileJson) {
+                const tiles = tileJson.tiles.map((tile) => this._proxyPath + this._getAbsoluteUrl(tile));
+                return Object.assign(Object.assign({}, tileJson), { tiles });
+            }
+            else {
+                return;
+            }
+        });
+    }
+    getUrlTemplate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tileJson = yield this._getRasterStyleJson();
+            if (tileJson) {
+                const directUrl = this._proxyPath + this._getAbsoluteUrl(tileJson.tiles[0]);
+                return this._emsClient.extendUrlWithParams(directUrl);
+            }
+            else {
+                return '';
+            }
+        });
+    }
+    getUrlTemplateForVector(sourceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const tileJson = yield this._getVectorStyleJsonInlined();
+            const url = (_b = (_a = tileJson === null || tileJson === void 0 ? void 0 : tileJson.sources[sourceId]) === null || _a === void 0 ? void 0 : _a.tiles) === null || _b === void 0 ? void 0 : _b.pop();
+            if (url) {
+                const directUrl = this._proxyPath + this._getAbsoluteUrl(url);
+                return this._emsClient.extendUrlWithParams(directUrl);
+            }
+            else {
+                return '';
+            }
+        });
+    }
+    getVectorStyleSheet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getVectorStyleJsonInlined();
+        });
+    }
+    getVectorStyleSheetRaw() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._getVectorStyleJsonRaw();
+        });
+    }
+    getSpriteSheetMeta() {
+        return __awaiter(this, arguments, void 0, function* (isRetina = false) {
+            const metaUrl = yield this.getSpriteSheetJsonPath(isRetina);
+            const spritePngs = yield this.getSpriteSheetPngPath(isRetina);
+            if (metaUrl && spritePngs) {
+                const metaUrlExtended = this._emsClient.extendUrlWithParams(metaUrl);
+                const jsonMeta = yield this._emsClient.getManifest(metaUrlExtended);
+                return {
+                    png: spritePngs,
+                    json: jsonMeta,
+                };
+            }
+            else {
+                return;
+            }
+        });
+    }
+    getSpriteSheetJsonPath() {
+        return __awaiter(this, arguments, void 0, function* (isRetina = false) {
+            const spriteSheetRootPath = yield this._getSpriteSheetRootPath();
+            if (spriteSheetRootPath) {
+                const suffix = isRetina ? '@2x' : '';
+                return spriteSheetRootPath + suffix + '.json';
+            }
+            else {
+                return '';
+            }
+        });
+    }
+    getSpriteSheetPngPath() {
+        return __awaiter(this, arguments, void 0, function* (isRetina = false) {
+            const spriteSheetRootPath = yield this._getSpriteSheetRootPath();
+            if (spriteSheetRootPath) {
+                const suffix = isRetina ? '@2x' : '';
+                return spriteSheetRootPath + suffix + '.png';
+            }
+            else {
+                return '';
+            }
+        });
+    }
+    getDisplayName() {
+        return this._emsClient.getValueInLanguage(this._config.name);
+    }
+    getMinZoom() {
+        return __awaiter(this, arguments, void 0, function* (format = 'vector') {
+            switch (format) {
+                case 'vector': {
+                    const { sources } = (yield this._getVectorStyleJsonInlined()) || { sources: {} };
+                    return Math.min(...Object.values(sources)
+                        .map((s) => {
+                        return s && s instanceof Object && 'minzoom' in s ?
+                            s['minzoom'] :
+                            null;
+                    })
+                        .filter((minzoom) => Number.isFinite(minzoom)));
+                }
+                case 'raster': {
+                    const { minzoom } = (yield this._getRasterStyleJson()) || {};
+                    return minzoom;
+                }
+                default:
+                    return;
+            }
+        });
+    }
+    getMaxZoom() {
+        return __awaiter(this, arguments, void 0, function* (format = 'vector') {
+            switch (format) {
+                case 'vector': {
+                    const { sources } = (yield this._getVectorStyleJsonInlined()) || { sources: {} };
+                    return Math.max(...Object.values(sources)
+                        .map((s) => {
+                        return s && s instanceof Object && 'maxzoom' in s ?
+                            s['maxzoom'] :
+                            null;
+                    })
+                        .filter((maxzoom) => Number.isFinite(maxzoom)));
+                }
+                case 'raster': {
+                    const { maxzoom } = (yield this._getRasterStyleJson()) || {};
+                    return maxzoom;
+                }
+                default:
+                    return;
+            }
+        });
+    }
+    getId() {
+        return this._config.id;
+    }
+    hasId(id) {
+        return this._config.id === id;
+    }
+    getApiUrl() {
+        return this._emsClient.getTileApiUrl();
+    }
+    _getStyleUrlForLocale(formatType) {
+        let vectorFormats = this._getFormats(formatType, this._emsClient.getLocale());
+        if (!vectorFormats.length) {
+            //fallback to default locale
+            vectorFormats = this._getFormats(formatType, this._emsClient.getDefaultLocale());
+        }
+        if (!vectorFormats.length) {
+            throw new Error(`Cannot find ${formatType} tile layer for locale ${this._emsClient.getLocale()} or ${this._emsClient.getDefaultLocale()}`);
+        }
+        const defaultStyle = vectorFormats[0];
+        if (defaultStyle && Object.prototype.hasOwnProperty.call(defaultStyle, 'url')) {
+            return defaultStyle.url;
+        }
+    }
+    _getFormats(formatType, locale) {
+        return this._config.formats.filter((format) => format.locale === locale && format.format === formatType);
+    }
+    _getSpriteSheetRootPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vectorStyleJson = yield this._getVectorStyleJsonRaw();
+            if (vectorStyleJson === null || vectorStyleJson === void 0 ? void 0 : vectorStyleJson.sprite) {
+                return this._proxyPath + this._getAbsoluteUrl(vectorStyleJson.sprite);
+            }
+            else {
+                return '';
+            }
+        });
+    }
+    _getUrlTemplateForGlyphs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vectorStyleJson = yield this._getVectorStyleJsonRaw();
+            if (vectorStyleJson === null || vectorStyleJson === void 0 ? void 0 : vectorStyleJson.glyphs) {
+                return this._proxyPath + this._getAbsoluteUrl(vectorStyleJson.glyphs);
+            }
+            else {
+                return '';
+            }
+        });
+    }
+}
+exports.TMSService = TMSService;
+/*
+List of supported languages with labels and OMT codes extracted
+from https://openmaptiles.org/languages
+
+Keys are values for i18.locale from Kibana settings
+and OMT codes for the rest.
+*/
+TMSService.SupportedLanguages = [
+    { key: 'ar', omt: 'ar' },
+    { key: 'az', omt: 'az' },
+    { key: 'be', omt: 'be' },
+    { key: 'bg', omt: 'bg' },
+    { key: 'br', omt: 'br' },
+    { key: 'bs', omt: 'bs' },
+    { key: 'ca', omt: 'ca' },
+    { key: 'cs', omt: 'cs' },
+    { key: 'cy', omt: 'cy' },
+    { key: 'da', omt: 'da' },
+    { key: 'de', omt: 'de' },
+    { key: 'el', omt: 'el' },
+    { key: 'en', omt: 'en' },
+    { key: 'eo', omt: 'eo' },
+    { key: 'es', omt: 'es' },
+    { key: 'et', omt: 'et' },
+    { key: 'fi', omt: 'fi' },
+    { key: 'fr-fr', omt: 'fr' },
+    { key: 'fy', omt: 'fy' },
+    { key: 'ga', omt: 'ga' },
+    { key: 'gd', omt: 'gd' },
+    { key: 'he', omt: 'he' },
+    { key: 'hi-in', omt: 'hi' },
+    { key: 'hr', omt: 'hr' },
+    { key: 'hu', omt: 'hu' },
+    { key: 'hy', omt: 'hy' },
+    { key: 'is', omt: 'is' },
+    { key: 'it', omt: 'it' },
+    { key: 'ja_kana', omt: 'ja_kana' },
+    { key: 'ja_rm', omt: 'ja_rm' },
+    { key: 'ja-jp', omt: 'ja' },
+    { key: 'ka', omt: 'ka' },
+    { key: 'kk', omt: 'kk' },
+    { key: 'kn', omt: 'kn' },
+    { key: 'ko_rm', omt: 'ko_rm' },
+    { key: 'ko', omt: 'ko' },
+    { key: 'la', omt: 'la' },
+    { key: 'lb', omt: 'lb' },
+    { key: 'lt', omt: 'lt' },
+    { key: 'lv', omt: 'lv' },
+    { key: 'mk', omt: 'mk' },
+    { key: 'mt', omt: 'mt' },
+    { key: 'nl', omt: 'nl' },
+    { key: 'no', omt: 'no' },
+    { key: 'pl', omt: 'pl' },
+    { key: 'pt-pt', omt: 'pt' },
+    { key: 'rm', omt: 'rm' },
+    { key: 'ro', omt: 'ro' },
+    { key: 'ru-ru', omt: 'ru' },
+    { key: 'sk', omt: 'sk' },
+    { key: 'sl', omt: 'sl' },
+    { key: 'sq', omt: 'sq' },
+    { key: 'sr-Ltn', omt: 'sr-Ltn' },
+    { key: 'sr', omt: 'sr' },
+    { key: 'sv', omt: 'sv' },
+    { key: 'th', omt: 'th' },
+    { key: 'tr', omt: 'tr' },
+    { key: 'uk', omt: 'uk' },
+    { key: 'zh-cn', omt: 'zh' },
+];
+/*
+Suggested default operations for the different EMS styles
+*/
+TMSService.colorOperationDefaults = [
+    { style: 'road_map', operation: 'mix', percentage: 0.25 },
+    { style: 'road_map_desaturated', operation: 'screen', percentage: 0.25 },
+    { style: 'dark_map', operation: 'dodge', percentage: 0.25 },
+];

package/target/utils.d.ts

@@ -6,8 +6,8 @@ import { ColorSpecification, DataDrivenPropertyValueSpecification, PropertyValue
  * It also handles trailing slashes in tileApiUrl and fileApiUrl parameters.
  */
 export declare function toAbsoluteUrl(host: string | undefined, path: string): string;
-export declare type mbColorDefinition = PropertyValueSpecification<ColorSpecification> | DataDrivenPropertyValueSpecification<ColorSpecification>;
-export declare type layerPaintProperty = {
+export type mbColorDefinition = PropertyValueSpecification<ColorSpecification> | DataDrivenPropertyValueSpecification<ColorSpecification>;
+export type layerPaintProperty = {
     'background-color'?: PropertyValueSpecification<ColorSpecification>;
     'circle-color'?: DataDrivenPropertyValueSpecification<ColorSpecification>;
     'circle-stroke-color'?: DataDrivenPropertyValueSpecification<ColorSpecification>;
@@ -20,6 +20,6 @@ export declare type layerPaintProperty = {
     'text-color'?: DataDrivenPropertyValueSpecification<ColorSpecification>;
     'text-halo-color'?: DataDrivenPropertyValueSpecification<ColorSpecification>;
 };
-export declare type blendMode = Parameters<ChromaStatic['blend']>[2] | 'mix';
+export type blendMode = Parameters<ChromaStatic['blend']>[2] | 'mix';
 export declare function desaturateColor(paintColor: mbColorDefinition): mbColorDefinition;
 export declare function colorizeColor(sourceColor: mbColorDefinition, destColor: string, operation?: blendMode, percentage?: number): mbColorDefinition;

package/target/utils.js

@@ -0,0 +1,86 @@
+"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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorizeColor = exports.desaturateColor = exports.toAbsoluteUrl = void 0;
+const chroma_js_1 = __importDefault(require("chroma-js"));
+/**
+ * Resolves a target URL path relative to the host.
+ * This is specifically useed by the Kibana proxy re-routing.
+ * It also handles trailing slashes in tileApiUrl and fileApiUrl parameters.
+ */
+function toAbsoluteUrl(host, path) {
+    if (!host) {
+        return path;
+    }
+    const hostEndWithSlash = host[host.length - 1] === '/';
+    const pathStartsWithSlash = path[0] === '/';
+    if (hostEndWithSlash === true && pathStartsWithSlash === true) {
+        return host + path.slice(1);
+    }
+    else if (hostEndWithSlash !== pathStartsWithSlash) {
+        return host + path;
+    }
+    else {
+        return host + '/' + path;
+    }
+}
+exports.toAbsoluteUrl = toAbsoluteUrl;
+/*
+Function to transform a maplibre color definition by a given function.
+*/
+function transformColor(paintColor, func) {
+    if (typeof paintColor == 'string') {
+        const modifiedColor = func(paintColor);
+        return `rgba(${modifiedColor.rgba().join(',')})`;
+    }
+    else if (typeof paintColor == 'object' &&
+        'stops' in paintColor &&
+        Array.isArray(paintColor === null || paintColor === void 0 ? void 0 : paintColor.stops)) {
+        const stops = paintColor['stops'].map((stop) => {
+            const newColor = transformColor(stop[1], func);
+            return [stop[0], newColor];
+        });
+        const newPaintColor = Object.assign({}, paintColor, { stops });
+        return newPaintColor;
+    }
+    else
+        return paintColor;
+}
+/*
+This is the function used to generate the current EMS desaturated roadmap
+*/
+function desaturateColor(paintColor) {
+    return transformColor(paintColor, (color) => {
+        return (0, chroma_js_1.default)(color).desaturate(1.1).brighten(0.33);
+    });
+}
+exports.desaturateColor = desaturateColor;
+/*
+Blends an original maplibre color definition with a destination
+color. Accepts different blending modes and an additional `mix`
+option that needs a percentage.
+
+More details:
+
+https://gka.github.io/chroma.js/#chroma-blend
+https://gka.github.io/chroma.js/#chroma-mix
+*/
+function colorizeColor(sourceColor, destColor, operation = 'screen', percentage = 0.5) {
+    return transformColor(sourceColor, (color) => {
+        if (operation !== 'mix') {
+            return chroma_js_1.default.blend((0, chroma_js_1.default)(color), destColor, operation);
+        }
+        else {
+            return chroma_js_1.default.mix((0, chroma_js_1.default)(color), destColor, percentage);
+        }
+    });
+}
+exports.colorizeColor = colorizeColor;