@gravitee/ui-components 3.25.3-typescript-bfd8f67 → 3.25.3-typescript-94e8113

package/dist/src/lib/schema-form.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function isCodemirror(control) {
+    return control['x-schema-form'] && control['x-schema-form'].type === 'codemirror';
+}
+export function isObject(control) {
+    return control.type === 'object';
+}
+export function isComplexArray(control) {
+    return control.type === 'array' && !control.items.enum;
+}
+export function canInline(schema) {
+    if (schema.properties) {
+        const keys = Object.keys(schema.properties);
+        return keys.length === 2 && keys.filter((key) => _canInline(schema, key)).length === keys.length;
+    }
+    return true;
+}
+function _canInline(schema, key) {
+    const property = schema.properties[key];
+    return !isCodemirror(property) && !isObject(property) && !isComplexArray(property);
+}
+export function canGrid(schema) {
+    const keys = Object.keys(schema.properties);
+    return keys.length > 2 && keys.filter((key) => _canInline(schema, key)).length === keys.length;
+}

package/dist/src/lib/studio.d.ts

@@ -0,0 +1,2 @@
+export function getFlowName(flow: any, collectionName: any, withMethods?: boolean, draggable?: boolean, compact?: boolean): any[];
+export const methods: import("lit").CSSResult;

package/dist/src/lib/studio.js

@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { html, css } from 'lit';
+import { classMap } from 'lit/directives/class-map';
+import '../atoms/gv-icon';
+import '../atoms/gv-tag';
+// language=CSS
+export const methods = css `
+  gv-tag {
+    font-family: monospace;
+  }
+
+  gv-tag.ALL {
+    --gv-tag--bdc: #262626;
+    --gv-tag--bgc: #262626;
+    --gv-tag--c: white;
+  }
+
+  gv-tag.POST {
+    --gv-tag--bdc: #fb8c00;
+    --gv-tag--bgc: #fb8c00;
+    --gv-tag--c: white;
+  }
+
+  gv-tag.PUT {
+    --gv-tag--bdc: #039be5;
+    --gv-tag--bgc: #039be5;
+    --gv-tag--c: white;
+  }
+
+  gv-tag.GET {
+    --gv-tag--bdc: #43a047;
+    --gv-tag--bgc: #43a047;
+    --gv-tag--c: white;
+  }
+
+  gv-tag.DELETE {
+    --gv-tag--bdc: #e53935;
+    --gv-tag--bgc: #e53935;
+    --gv-tag--c: white;
+  }
+
+  .flow-path,
+  .plan-name {
+    margin-left: 0.2rem;
+    display: flex;
+    align-items: center;
+  }
+
+  .collection-name {
+    margin-right: 0.5rem;
+    --gv-icon--s: 26px;
+    --gv-icon--c: #5a7684;
+    --gv-icon-opacity--c: #5a7684;
+  }
+
+  .icon-type {
+    --gv-icon--s: 26px;
+    --gv-icon--c: #383e3f;
+    --gv-icon-opacity--c: #5a7684;
+  }
+`;
+export function getFlowName(flow, collectionName, withMethods = true, draggable = false, compact = true) {
+    let rendering = [];
+    if (flow) {
+        if (draggable) {
+            rendering.push(html `<gv-icon title="Drag for reorder" class="draggable-icon" shape="general:sort"></gv-icon>`);
+        }
+        const methods = flow.methods || [];
+        if (flow.type != null) {
+            let shape = null;
+            if (flow.type.toUpperCase() === 'ROOT') {
+                shape = 'home:earth';
+            }
+            else if (flow.type.toUpperCase() === 'LOGIN') {
+                shape = 'general:shield-protected';
+            }
+            else if (flow.type.toUpperCase() === 'CONSENT') {
+                shape = 'general:shield-check';
+            }
+            else if (flow.type.toUpperCase() === 'REGISTER') {
+                shape = 'communication:shield-user';
+            }
+            if (shape != null) {
+                rendering = [...rendering, html `<gv-icon title="${flow.type}" shape="${shape}" class="icon-type"></gv-icon>`];
+            }
+        }
+        else if (withMethods) {
+            const renderingMethods = methods.map((method) => html `<gv-tag class="${method.toUpperCase()}">${method.toUpperCase()}</gv-tag>`);
+            if (compact && (renderingMethods.length === 9 || renderingMethods.length === 0)) {
+                rendering = [...rendering, html `<gv-tag major title="${methods.join('\n')}">ALL</gv-tag>`];
+            }
+            else if (compact && renderingMethods.length >= 3) {
+                const renderingMethodsCompact = renderingMethods.slice(0, 2);
+                renderingMethodsCompact.push(html `<gv-tag minor title="${methods.join('\n')}">+${renderingMethods.length - 2}</gv-tag>`);
+                rendering = [...rendering, ...renderingMethodsCompact];
+            }
+            else {
+                rendering = [...rendering, ...renderingMethods];
+            }
+        }
+        const classes = {
+            'flow-path': true,
+            disabled: flow.disabled,
+        };
+        if (flow.name != null && flow.name.trim() !== '') {
+            if (flow._dirty) {
+                rendering.push(html `<div class="${classMap(classes)}"><mark>${flow.name}</mark></div>`);
+            }
+            else {
+                rendering.push(html `<div class="${classMap(classes)}">${flow.name}</div>`);
+            }
+        }
+        else if (flow['path-operator']) {
+            const path = flow['path-operator'].path || '/';
+            if (path) {
+                const pathWithOperator = flow['path-operator'].operator === 'STARTS_WITH' ? `${path.endsWith('/') ? path : `${path}/`}**` : path;
+                if (flow._dirty) {
+                    rendering.push(html `<div class="${classMap(classes)}"><mark>${pathWithOperator}</mark></div>`);
+                }
+                else {
+                    rendering.push(html `<div class="${classMap(classes)}">${pathWithOperator}</div>`);
+                }
+            }
+        }
+        if (collectionName) {
+            rendering.push(html `<div class="collection-name">${collectionName}</div>`);
+        }
+    }
+    return rendering;
+}

package/dist/src/lib/style.d.ts

@@ -0,0 +1,6 @@
+export function hexToRGB(hex: any): {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+export function getCssVar(element: any, variableName: any, defaultValue: any): any;

package/dist/src/lib/style.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getPropertyValue(element, propertyName, defaultValue) {
+    /* global getComputedStyle */
+    const value = getComputedStyle(element).getPropertyValue(propertyName);
+    return value.trim() || defaultValue;
+}
+export const getCssVar = function getCssVar(element, variableName, defaultValue) {
+    if (element) {
+        if (variableName.startsWith('--')) {
+            return getPropertyValue(element, variableName, defaultValue);
+        }
+        return getPropertyValue(element, `--${variableName}`, defaultValue);
+    }
+    return defaultValue;
+};
+export function hexToRGB(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex.trim());
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : null;
+}

package/dist/src/lib/text-format.d.ts

@@ -0,0 +1,6 @@
+export function loadAsciiDoctor(): Promise<any>;
+export function setAsciiDoctorAsGlobal(asciidoctor: any, highlightJsExt: any): any;
+export function toDom(text: any, type?: string, small?: boolean): Promise<{
+    title: string;
+    element: HTMLDivElement;
+} | undefined>;

package/dist/src/lib/text-format.js

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function loadAsciiDoctor() {
+    if (window._gvAsciidoctor == null) {
+        return Promise.all([import('asciidoctor'), import('asciidoctor-highlight.js')]).then(([asciidoctor, highlightJsExt]) => {
+            window._gvAsciidoctor = asciidoctor.default();
+            highlightJsExt.default.register(window._gvAsciidoctor.Extensions);
+            return setAsciiDoctorAsGlobal(asciidoctor.default, highlightJsExt.default);
+        });
+    }
+    return Promise.resolve(window._gvAsciidoctor);
+}
+export function setAsciiDoctorAsGlobal(asciidoctor, highlightJsExt) {
+    if (window._gvAsciidoctor == null) {
+        window._gvAsciidoctor = asciidoctor();
+        highlightJsExt.register(window._gvAsciidoctor.Extensions);
+    }
+    return window._gvAsciidoctor;
+}
+export function toDom(text, type = 'adoc', small = false) {
+    return loadAsciiDoctor().then((asciidoctor) => {
+        if (text) {
+            let innerHTML = '';
+            if (type === 'adoc') {
+                innerHTML = asciidoctor.convert(text, {
+                    attributes: {
+                        showtitle: true,
+                        'source-highlighter': 'highlightjs-ext',
+                    },
+                });
+            }
+            else {
+                throw new Error(`Library not found for type : '${type}' | ${text}`);
+            }
+            const element = document.createElement('div');
+            element.innerHTML = innerHTML;
+            element.style.width = '100%';
+            element.style.maxWidth = '1000px';
+            element.style.margin = '0 auto';
+            element.classList.add('markdown-body');
+            if (small) {
+                element.classList.add('small');
+            }
+            const titleElement = element.querySelector('h1');
+            let title = '';
+            if (titleElement) {
+                title = titleElement.textContent;
+            }
+            return { title, element };
+        }
+    });
+}

package/dist/src/lib/theme.d.ts

@@ -0,0 +1,4 @@
+export function applyTheme(theme: any): void;
+export function updateImage(name: any, value: any, defaultValue: any): void;
+export function updateFavicon(value: any, defaultValue: any): void;
+export function getApplicationTypeIcon(type: any): "devices:laptop" | "devices:android" | "devices:server" | "layout:layout-top-panel-2";

package/dist/src/lib/theme.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function applyTheme(theme) {
+    if (theme) {
+        const logo = theme._links ? theme._links.logo : theme.logo;
+        const optionalLogo = theme._links ? theme._links.optionalLogo : theme.optionalLogo;
+        const backgroundImage = theme._links ? theme._links.backgroundImage : theme.backgroundImage;
+        updateImage('--gv-theme-logo', logo, `url('/images/gravitee-logo-cyan.svg')`);
+        updateImage('--gv-theme-optional-logo', optionalLogo, `url('/images/gravitee-logo-white.svg')`);
+        updateImage('--gv-theme-homepage-background-image', backgroundImage, `none`);
+        const favicon = theme._links ? theme._links.favicon : theme.favicon;
+        updateFavicon(favicon, 'images/gravitee-favicon.png');
+        theme.definition.data.forEach((component) => {
+            component.css.forEach((cssProperty) => {
+                document.documentElement.style.setProperty(cssProperty.name, cssProperty.value);
+            });
+        });
+    }
+}
+export function updateImage(name, value, defaultValue) {
+    setTimeout(() => {
+        const propertyValue = value ? `url(${value})` : 'none';
+        document.documentElement.style.setProperty(name, propertyValue);
+    }, 0);
+}
+export function updateFavicon(value, defaultValue) {
+    let link = document.querySelector("link[rel~='icon']");
+    if (!link) {
+        link = document.createElement('link');
+        link.rel = 'icon';
+        document.getElementsByTagName('head')[0].appendChild(link);
+    }
+    link.href = value || defaultValue;
+}
+export function getApplicationTypeIcon(type) {
+    switch (type.toLowerCase()) {
+        case 'browser':
+        case 'web':
+            return 'devices:laptop';
+        case 'native':
+            return 'devices:android';
+        case 'backend_to_backend':
+            return 'devices:server';
+        default:
+            return 'layout:layout-top-panel-2';
+    }
+}

package/dist/src/lib/utils.d.ts

@@ -0,0 +1,9 @@
+export function truncate(text: any, limit?: number, suffix?: string): any;
+export function isSameRoutes(routes: any, futureRoutes: any): boolean;
+export function appendDraggableImage(src: any, size?: number, defaultIcon?: string): HTMLDivElement;
+export function flatDeep(arr: any): any;
+export function flatObject(obj: any, prefix?: string): {};
+export function deepClone(obj: any): any;
+export function uuid(): string;
+export function deepEqual(a: any, b: any, withoutOrder?: boolean): boolean;
+export function isObject(object: any): boolean;

package/dist/src/lib/utils.js

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function truncate(text, limit = 250, suffix = '...') {
+    return text && text.length > limit ? `${text.substring(0, limit)}${suffix}` : text;
+}
+export function isSameRoutes(routes, futureRoutes) {
+    if (routes && futureRoutes) {
+        return JSON.stringify(routes.map((r) => r.path + r.active)) === JSON.stringify(futureRoutes.map((r) => r.path + r.active));
+    }
+    return false;
+}
+export function appendDraggableImage(src, size = 100, defaultIcon = 'communication:shield-thunder') {
+    // Usefull when image src is svg
+    const div = document.createElement('div');
+    div.style.position = 'fixed';
+    div.style.left = '-999px';
+    div.style.top = '-999px';
+    div.style.zIndex = 1000;
+    if (src != null) {
+        const image = new Image();
+        image.src = src;
+        image.style = `width:${size}px;height:${size}px`;
+        div.appendChild(image);
+    }
+    else {
+        const svgElem = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+        const useElem = document.createElementNS('http://www.w3.org/2000/svg', 'use');
+        useElem.setAttributeNS('http://www.w3.org/1999/xlink', 'xlink:href', defaultIcon);
+        svgElem.appendChild(useElem);
+        div.appendChild(svgElem);
+    }
+    document.body.appendChild(div);
+    return div;
+}
+export function flatDeep(arr) {
+    return arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatDeep(val) : val), []);
+}
+export function flatObject(obj, prefix = '') {
+    return Object.keys(obj).reduce((acc, k) => {
+        const pre = prefix.length ? prefix + '.' : '';
+        if (Array.isArray(obj[k]))
+            acc[pre + k] = obj[k];
+        else if (typeof obj[k] === 'object')
+            Object.assign(acc, flatObject(obj[k], pre + k));
+        else
+            acc[pre + k] = obj[k];
+        return acc;
+    }, {});
+}
+export function deepClone(obj) {
+    if (obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+    return obj;
+}
+export function uuid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+export function deepEqual(a, b, withoutOrder = false) {
+    if (Array.isArray(a) && Array.isArray(b) && withoutOrder) {
+        if (a.length !== b.length)
+            return false;
+        const uniqueValues = new Set([...a, ...b]);
+        for (const v of uniqueValues) {
+            const aCount = a.filter((e) => e === v).length;
+            const bCount = b.filter((e) => e === v).length;
+            if (aCount !== bCount)
+                return false;
+        }
+        return true;
+    }
+    const keys1 = a != null ? Object.keys(a) : [];
+    const keys2 = b != null ? Object.keys(b) : [];
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        const val1 = a[key];
+        const val2 = b[key];
+        const areObjects = isObject(val1) && isObject(val2);
+        if ((areObjects && !deepEqual(val1, val2)) || (!areObjects && val1 !== val2)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isObject(object) {
+    return object != null && typeof object === 'object';
+}

package/dist/src/mixins/chart-element.d.ts

@@ -0,0 +1,39 @@
+/**
+ * This is a mixin for ChartElement
+ * @mixinFunction
+ */
+export function ChartElement(ParentClass: any): {
+    new (): {
+        [x: string]: any;
+        _skeletonAttribute: string;
+        _eventListener: () => void;
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        getOptions(): Promise<void>;
+        updated(changedProperties: any): void;
+        _additionalOptions: void | undefined;
+        render(): import("lit-html").TemplateResult<1>;
+        _invisible: boolean;
+        _skeleton: boolean;
+        _error: boolean;
+        _empty: boolean;
+    };
+    readonly properties: {
+        /** @required */
+        series: {
+            type: ArrayConstructor;
+        };
+        options: {
+            type: ArrayConstructor;
+        };
+        _additionalOptions: {
+            type: ObjectConstructor;
+            attribute: boolean;
+        };
+        _series: {
+            type: ArrayConstructor;
+            attribute: boolean;
+        };
+    };
+    readonly styles: import("lit").CSSResult[];
+};

package/dist/src/mixins/chart-element.js

@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { html, css } from 'lit';
+import { i18n } from '../lib/i18n';
+import Highcharts from 'highcharts';
+import Highmaps from 'highcharts/highmaps';
+import { cache } from 'lit/directives/cache';
+import { withSkeletonAttribute } from './with-skeleton-attribute';
+/**
+ * This is a mixin for ChartElement
+ * @mixinFunction
+ */
+export function ChartElement(ParentClass) {
+    /**
+     * @mixinClass
+     */
+    return class extends withSkeletonAttribute(ParentClass) {
+        static get properties() {
+            return {
+                /** @required */
+                series: { type: Array },
+                options: { type: Array },
+                _additionalOptions: { type: Object, attribute: false },
+                _series: { type: Array, attribute: false },
+            };
+        }
+        static get styles() {
+            return [
+                ...super.styles,
+                // language=CSS
+                css `
+          :host {
+            box-sizing: border-box;
+            display: flex;
+            height: 100%;
+            width: 100%;
+            flex-direction: column;
+            justify-content: center;
+            align-content: center;
+          }
+
+          .container {
+            flex: 1;
+          }
+
+          .tooltip {
+            display: grid;
+          }
+
+          .tooltip-2 {
+            grid-template-columns: repeat(2, 1fr);
+          }
+
+          .tooltip-3 {
+            grid-template-columns: repeat(3, 1fr);
+          }
+
+          .tooltip-4 {
+            grid-template-columns: repeat(4, 1fr);
+          }
+
+          .tooltip-5 {
+            grid-template-columns: repeat(5, 1fr);
+          }
+        `,
+            ];
+        }
+        constructor() {
+            super();
+            this._skeletonAttribute = 'series';
+            this._eventListener = function eventListener() {
+                for (let i = 0; i < Highcharts.charts.length; i++) {
+                    Highcharts.charts[i].reflow();
+                }
+            };
+        }
+        connectedCallback() {
+            super.connectedCallback();
+            window.addEventListener('resize', this._eventListener);
+        }
+        disconnectedCallback() {
+            super.disconnectedCallback();
+            window.removeEventListener('resize', this._eventListener);
+        }
+        async getOptions() { }
+        updated(changedProperties) {
+            super.updated(changedProperties);
+            if (changedProperties.has('_series')) {
+                this.getOptions().then((options) => {
+                    this._additionalOptions = options;
+                });
+            }
+        }
+        render() {
+            if (this._error) {
+                return html ` <div class="error">${i18n('gv-chart.error')}</div>`;
+            }
+            if (this._empty) {
+                return html ` <div class="empty">${i18n('gv-chart.empty')}</div>`;
+            }
+            const container = document.createElement('div');
+            container.id = 'container';
+            container.className = this._skeleton || this._additionalOptions == null ? 'skeleton' : '';
+            container.classList.add('container');
+            if (this._additionalOptions) {
+                const options = {
+                    ...{
+                        chart: {
+                            height: '100%',
+                            width: '100%',
+                        },
+                        credits: {
+                            enabled: false,
+                        },
+                        title: {
+                            text: '',
+                        },
+                        time: {
+                            useUTC: false,
+                        },
+                    },
+                    ...this._additionalOptions,
+                };
+                const hasData = this._series && this._series.values && this._series.values[0] && this._series.values[0].data;
+                if (hasData) {
+                    options.series = this._series && this._series.values;
+                }
+                setTimeout(() => {
+                    if (options.chart.map) {
+                        Highmaps.mapChart(container, options);
+                    }
+                    else {
+                        Highcharts.chart(container, options);
+                    }
+                });
+            }
+            return html `${cache(container)}`;
+        }
+    };
+}