@elastic/ems-client 8.5.1 → 8.5.2

package/.buildkite/pipeline.yml

@@ -1,5 +1,5 @@
 agents:
-  image: "docker.elastic.co/ci-agent-images/ems/buildkite-agent-node20:0.1"
+  image: "docker.elastic.co/ci-agent-images/ems/buildkite-agent-node20:0.4"
   cpu: "2"
   memory: "2G"
 

package/.husky/pre-commit

@@ -0,0 +1 @@
+yarn test

package/CHANGELOG.md

@@ -3,6 +3,11 @@ 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/).
 
+## [8.5.2] - 2024-07-05
+
+## Changed
+- Update dependencies #232 #233 #234 #235 
+
 ## [8.5.1] - 2023-11-09
 
 ### Added

package/eslint.config.mjs

@@ -0,0 +1,25 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import globals from 'globals';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    ignores: ["target","*.config.js"]
+  },
+  {
+    files: ['**/*.{ts,tsx,mts,cts}'],
+    rules: {
+      'no-undef': 'off',
+      '@typescript-eslint/ban-types': 'off'
+    },
+    "languageOptions": {
+      "globals": {
+        ...globals.node
+      }
+    }
+  },
+);

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@elastic/ems-client",
-  "version": "8.5.1",
+  "version": "8.5.2",
   "description": "JavaScript client library for the Elastic Maps Service",
   "main": "target/node/index.js",
   "browser": "target/web/index.js",
   "types": "target/index.d.ts",
   "scripts": {
+    "prepare": "husky",
     "prelint": "tsc --noEmit",
-    "lint": "eslint . --ext .ts,.tsx",
+    "lint": "prettier --check src/* && eslint .",
     "pretest": "yarn lint",
     "test": "jest",
     "build": "tsc --emitDeclarationOnly && yarn build-web && yarn build-node",
@@ -29,20 +30,14 @@
     "url": "https://github.com/elastic/ems-client/issues"
   },
   "homepage": "https://github.com/elastic/ems-client#readme",
-  "husky": {
-    "hooks": {
-      "pre-commit": "yarn test"
-    }
-  },
   "dependencies": {
-    "@types/geojson": "^7946.0.10",
-    "@types/lru-cache": "^5.1.0",
-    "@types/topojson-client": "^3.1.1",
-    "@types/topojson-specification": "^1.0.1",
+    "@types/geojson": "^7946.0.14",
+    "@types/topojson-client": "^3.1.4",
+    "@types/topojson-specification": "^1.0.5",
     "chroma-js": "^2.1.0",
     "lodash": "^4.17.15",
-    "lru-cache": "^6.0.0",
-    "semver": "7.5.4",
+    "lru-cache": "7.18.3",
+    "semver": "7.6.2",
     "topojson-client": "^3.1.0"
   },
   "devDependencies": {
@@ -51,25 +46,30 @@
     "@babel/plugin-proposal-class-properties": "^7.5.5",
     "@babel/preset-env": "^7.5.5",
     "@babel/preset-typescript": "^7.9.0",
+    "@eslint/js": "^9.3.0",
     "@types/chroma-js": "^2.1.3",
-    "@types/jest": "^26.0.10",
+    "@types/eslint__js": "^8.42.3",
+    "@types/jest": "^29.5.12",
     "@types/lodash": "^4.14.150",
-    "@types/node": "^13.13.5",
+    "@types/lru-cache": "^7.10.10",
+    "@types/node": "^20.12.13",
     "@types/node-fetch": "^2.5.7",
     "@types/semver": "^7.1.0",
-    "@typescript-eslint/eslint-plugin": "^2.33.0",
-    "@typescript-eslint/parser": "^2.33.0",
-    "babel-jest": "^26.3.0",
-    "eslint": "^7.0.0",
-    "eslint-config-prettier": "^6.11.0",
-    "eslint-plugin-prettier": "^3.1.3",
-    "husky": "^4.2.5",
-    "jest": "^26.4.0",
-    "maplibre-gl": "2.1.9",
-    "node-fetch": "^2.6.1",
-    "prettier": "^2.0.5",
-    "ts-jest": "^26.2.0",
-    "typescript": "4.6.3"
+    "@typescript-eslint/eslint-plugin": "^7.11.0",
+    "@typescript-eslint/parser": "^7.11.0",
+    "babel-jest": "^29.7.0",
+    "eslint": "^9.3.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "globals": "^15.3.0",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "maplibre-gl": "3.1.0",
+    "node-fetch": "^2.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.4",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.11.0"
   },
   "engines": {
     "node": ">=18 <=20"

package/src/ems_client.ts

@@ -290,7 +290,11 @@ export class EMSClient {
       if (!response.ok) {
         throw new Error(response.statusText);
       }
-      return response ? await response.json() : null;
+      if (response) {
+        return (await response.json()) as Promise<T>;
+      } else {
+        throw new Error('Response not found');
+      }
     } catch (e) {
       if (e instanceof Error) {
         throw e;
@@ -307,7 +311,7 @@ export class EMSClient {
    */
   addQueryParams(additionalQueryParams: { [key: string]: string }): void {
     for (const key in additionalQueryParams) {
-      if (additionalQueryParams.hasOwnProperty(key)) {
+      if (Object.prototype.hasOwnProperty.call(additionalQueryParams, key)) {
         if (additionalQueryParams[key] !== this._queryParams[key]) {
           //changes detected.
           this._queryParams = _.assign({}, this._queryParams, additionalQueryParams);

package/src/tms_service.ts

@@ -169,9 +169,8 @@ export class TMSService extends AbstractEmsService {
         if (url) {
           const sourceUrl = this._proxyPath + this._getAbsoluteUrl(url);
           const extendedUrl = this._emsClient.extendUrlWithParams(sourceUrl);
-          const sourceJson = await this._emsClient.getManifest<VectorSourceSpecification>(
-            extendedUrl
-          );
+          const sourceJson =
+            await this._emsClient.getManifest<VectorSourceSpecification>(extendedUrl);
           const tiles = sourceJson?.tiles?.map((tileUrl) => {
             const directUrl = this._proxyPath + this._getAbsoluteUrl(tileUrl);
             return this._emsClient.extendUrlWithParams(directUrl);
@@ -374,16 +373,20 @@ export class TMSService extends AbstractEmsService {
 
   async getMinZoom(format = 'vector'): Promise<number | undefined> {
     switch (format) {
-      case 'vector':
+      case 'vector': {
         const { sources } = (await this._getVectorStyleJsonInlined()) || { sources: {} };
         return Math.min(
           ...Object.values(sources)
-            .map(({ minzoom }) => minzoom)
+            .map((s) => {
+              return s && s instanceof Object && 'minzoom' in s ? s['minzoom'] : null;
+            })
             .filter((minzoom): minzoom is number => Number.isFinite(minzoom))
         );
-      case 'raster':
+      }
+      case 'raster': {
         const { minzoom } = (await this._getRasterStyleJson()) || {};
         return minzoom;
+      }
       default:
         return;
     }
@@ -391,16 +394,20 @@ export class TMSService extends AbstractEmsService {
 
   async getMaxZoom(format = 'vector'): Promise<number | undefined> {
     switch (format) {
-      case 'vector':
+      case 'vector': {
         const { sources } = (await this._getVectorStyleJsonInlined()) || { sources: {} };
         return Math.max(
           ...Object.values(sources)
-            .map(({ maxzoom }) => maxzoom)
+            .map((s) => {
+              return s && s instanceof Object && 'maxzoom' in s ? s['maxzoom'] : null;
+            })
             .filter((maxzoom): maxzoom is number => Number.isFinite(maxzoom))
         );
-      case 'raster':
+      }
+      case 'raster': {
         const { maxzoom } = (await this._getRasterStyleJson()) || {};
         return maxzoom;
+      }
       default:
         return;
     }
@@ -425,13 +432,12 @@ export class TMSService extends AbstractEmsService {
       vectorFormats = this._getFormats(formatType, this._emsClient.getDefaultLocale());
     }
     if (!vectorFormats.length) {
-      // eslint-disable-next-line max-len
       throw new Error(
         `Cannot find ${formatType} tile layer for locale ${this._emsClient.getLocale()} or ${this._emsClient.getDefaultLocale()}`
       );
     }
     const defaultStyle = vectorFormats[0];
-    if (defaultStyle && defaultStyle.hasOwnProperty('url')) {
+    if (defaultStyle && Object.prototype.hasOwnProperty.call(defaultStyle, 'url')) {
       return defaultStyle.url;
     }
   }
@@ -445,7 +451,7 @@ export class TMSService extends AbstractEmsService {
   private async _getSpriteSheetRootPath(): Promise<string> {
     const vectorStyleJson = await this._getVectorStyleJsonRaw();
     if (vectorStyleJson?.sprite) {
-      return this._proxyPath + this._getAbsoluteUrl(vectorStyleJson.sprite);
+      return this._proxyPath + this._getAbsoluteUrl(vectorStyleJson.sprite.toString());
     } else {
       return '';
     }

package/target/ems_client.d.ts

@@ -2,10 +2,10 @@ import { TMSService } from './tms_service';
 import { EMSFormatType, FileLayer } from './file_layer';
 import { FeatureCollection } from 'geojson';
 export declare const LATEST_API_URL_PATH = "latest";
-declare type LocalizedStrings = {
+type LocalizedStrings = {
     [key: string]: string;
 };
-declare type BaseClientConfig = {
+type BaseClientConfig = {
     appName?: string;
     manifestServiceUrl?: string;
     tileApiUrl: string;
@@ -18,35 +18,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)[];
@@ -54,7 +54,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;
@@ -62,27 +62,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;