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

package/dist/src/lib/item.js

@@ -0,0 +1,110 @@
+/*
+ * 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 { getApplicationTypeIcon } from './theme';
+import { html } from 'lit';
+export function getVersion(item) {
+    if (item) {
+        if (item.version) {
+            return item.version;
+        }
+        else if (item.applicationType) {
+            const icon = getApplicationTypeIcon(item.applicationType);
+            return html `<gv-icon shape="${icon}"></gv-icon>`;
+        }
+    }
+    return null;
+}
+export function getTitle(item) {
+    if (item) {
+        return item.name;
+    }
+    return '';
+}
+export function getPicture(item) {
+    if (item) {
+        if (item.picture) {
+            return item.picture;
+        }
+        else if (item._links && item._links.picture) {
+            return item._links.picture;
+        }
+    }
+    return null;
+}
+export function getBackground(item) {
+    if (item) {
+        if (item.background) {
+            return item.background;
+        }
+        else if (item._links && item._links.background) {
+            return item._links.background;
+        }
+    }
+    return null;
+}
+export function getStates(item) {
+    if (item) {
+        return item.states;
+    }
+    return null;
+}
+export function getLabels(item) {
+    if (item) {
+        return item.labels;
+    }
+    return null;
+}
+export function getRating(item) {
+    if (item) {
+        return item.rating_summary;
+    }
+    return null;
+}
+export function getEntrypoints(item) {
+    if (item) {
+        return item.entrypoints || [];
+    }
+    return [];
+}
+export function getDescription(item) {
+    if (item) {
+        return item.description;
+    }
+    return '';
+}
+export function getOwner(item) {
+    if (item && item.owner) {
+        return item.owner.display_name;
+    }
+    return '';
+}
+export function getNbApisInView(item) {
+    if (item && item.total_apis != null) {
+        return item.total_apis;
+    }
+    return null;
+}
+export function getPictureDisplayName(item) {
+    if (item) {
+        if (item.version) {
+            return `${getTitle(item)}  ${item.version}`;
+        }
+        else if (item.applicationType) {
+            return `${getTitle(item)}  ${item.applicationType}  ${getOwner(item)}`;
+        }
+    }
+    return getTitle(item);
+}

package/dist/src/lib/properties.js

@@ -0,0 +1,171 @@
+/*
+ * 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.
+ */
+/**
+ * Thanks to https://github.com/CleverCloud/clever-client.js
+ *
+ * https://stackoverflow.com/questions/2821043/allowed-characters-in-linux-environment-variable-names
+ * Default bash/Linux rules are:
+ * letters (upper case only)
+ * digits (but not for first char)
+ * underscores
+ * nothing else
+ * /^[a-zA-Z_][a-zA-Z0-9_]*$/
+ */
+export const ENV_VAR_NAME_REGEX = /^[a-zA-Z0-9-_.]+$/;
+export function validateName(name) {
+    // return ENV_VAR_NAME_REGEX.test(name);
+    return true;
+}
+export const ERROR_TYPES = {
+    INVALID_NAME: 0,
+    DUPLICATED_NAME: 1,
+    INVALID_LINE: 2,
+    INVALID_VALUE: 3,
+};
+const NEW_LINE = '\n';
+const SIMPLE_QUOTE = "'";
+const EQUAL = '=';
+const SLASH = '\\';
+const SIMPLE_QUOTE_REPLACE = /([\\]*)'/g;
+const DOUBLE_QUOTE = '"';
+const DOUBLE_QUOTE_REPLACE = /([\\]*)"/g;
+function nextIndex(text, char, start = 0) {
+    let i = start;
+    let escaped = false;
+    while (i < text.length) {
+        if (text[i] === char && !escaped) {
+            return i;
+        }
+        escaped = text[i] === '\\';
+        i += 1;
+    }
+    return i;
+}
+function isEmptyLine(line) {
+    return line.trim() === '';
+}
+function isCommentLine(line) {
+    return line.trim().startsWith('#');
+}
+function getPosition(text, index) {
+    const lines = text.substring(0, index).split(NEW_LINE);
+    const line = lines.length;
+    const column = lines.slice(-1)[0].length;
+    return { line, column };
+}
+// Here we surround a string with double quotes,
+// it means we need to escape existing double quotes,
+// we need to do so in a way that is compatible with shells and environment variables,
+// this is why we have (slashes * 2 + 1).
+function doubleQuoteString(str) {
+    const escapedString = str.replace(DOUBLE_QUOTE_REPLACE, (m, slashes) => {
+        return SLASH.repeat(slashes.length * 2 + 1) + DOUBLE_QUOTE;
+    });
+    return DOUBLE_QUOTE + escapedString + DOUBLE_QUOTE;
+}
+// Here we must be able to reverse what doubleQuoteString() does,
+// with the same logic,
+// we also want it to work with simple quotes.
+function unquoteString(firstChar, str) {
+    if (firstChar === SIMPLE_QUOTE) {
+        return str.replace(SIMPLE_QUOTE_REPLACE, (match, slashes) => {
+            return SLASH.repeat((slashes.length - 1) / 2) + SIMPLE_QUOTE;
+        });
+    }
+    if (firstChar === DOUBLE_QUOTE) {
+        return str.replace(DOUBLE_QUOTE_REPLACE, (match, slashes) => {
+            return SLASH.repeat((slashes.length - 1) / 2) + DOUBLE_QUOTE;
+        });
+    }
+    return str;
+}
+export function parseRaw(rawInput = '') {
+    const parsedVariables = [];
+    const parsingErrors = [];
+    const allNames = new Set();
+    let startIdx = 0;
+    while (startIdx < rawInput.length) {
+        const nextNewLineIdx = nextIndex(rawInput, NEW_LINE, startIdx);
+        const line = rawInput.substring(startIdx, nextNewLineIdx);
+        if (isEmptyLine(line) || isCommentLine(line)) {
+            startIdx = nextNewLineIdx + 1;
+            continue;
+        }
+        if (!line.includes(EQUAL)) {
+            parsingErrors.push({ type: ERROR_TYPES.INVALID_LINE, pos: getPosition(rawInput, startIdx) });
+            startIdx = nextNewLineIdx + 1;
+            continue;
+        }
+        const nextEqualIdx = nextIndex(rawInput, EQUAL, startIdx);
+        const key = rawInput.substring(startIdx, nextEqualIdx);
+        if (!validateName(key)) {
+            parsingErrors.push({ type: ERROR_TYPES.INVALID_NAME, key, pos: getPosition(rawInput, startIdx) });
+        }
+        if (allNames.has(key)) {
+            parsingErrors.push({ type: ERROR_TYPES.DUPLICATED_NAME, key, pos: getPosition(rawInput, startIdx) });
+        }
+        else {
+            allNames.add(key);
+        }
+        const valueFirstChar = rawInput[nextEqualIdx + 1];
+        if (valueFirstChar === SIMPLE_QUOTE || valueFirstChar === DOUBLE_QUOTE) {
+            const nextQuoteIdx = nextIndex(rawInput, valueFirstChar, nextEqualIdx + 2);
+            const rawValue = rawInput.substring(nextEqualIdx + 2, nextQuoteIdx);
+            const value = unquoteString(valueFirstChar, rawValue);
+            parsedVariables.push({ key, value });
+            if (nextNewLineIdx > nextQuoteIdx + 1 || nextQuoteIdx + 1 > rawInput.length) {
+                parsingErrors.push({ type: ERROR_TYPES.INVALID_VALUE, key, pos: getPosition(rawInput, nextQuoteIdx + 1) });
+                startIdx = nextNewLineIdx + 1;
+            }
+            else {
+                startIdx = nextQuoteIdx + 1;
+            }
+        }
+        else {
+            const value = rawInput.substring(nextEqualIdx + 1, nextNewLineIdx);
+            parsedVariables.push({ key, value });
+            startIdx = nextNewLineIdx + 1;
+        }
+    }
+    // WARN: Array.prototype.sort edits in place
+    parsedVariables.sort((a, b) => a.key.localeCompare(b.key));
+    return { variables: parsedVariables, errors: parsingErrors };
+}
+// automatically merges duplicated named (keeps last value)
+// automatically removes variables with invalid names
+// always double quote values (with proper escaping)
+export function toNameEqualsValueString(variables, options = {}) {
+    const { addExports = false } = options;
+    return variables
+        .sort((a, b) => a.key.localeCompare(b.key))
+        .map(({ key, value }) => {
+        const quotedValue = doubleQuoteString(value);
+        const nameValue = `${key}=${quotedValue}`;
+        return addExports ? `export ${nameValue};` : nameValue;
+    })
+        .join('\n');
+}
+// automatically merges duplicated named (keeps last value)
+// automatically removes variables with invalid names
+export function toNameValueObject(variables) {
+    const keyValueObject = {};
+    variables
+        .filter(({ name }) => validateName(name))
+        .forEach(({ name, value }) => {
+        keyValueObject[name] = value;
+    });
+    return keyValueObject;
+}

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.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.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.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.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';
+    }
+}