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

package/dist/src/lib/http.js

@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2021 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 const statusCode = {
+    100: {
+        description: 'Continue',
+        constant: 'CONTINUE',
+    },
+    101: {
+        description: 'Switching Protocols',
+        constant: 'SWITCHING_PROTOCOLS',
+    },
+    102: {
+        description: 'Processing',
+        constant: 'PROCESSING',
+    },
+    200: {
+        description: 'OK',
+        constant: 'OK',
+    },
+    201: {
+        description: 'Created',
+        constant: 'CREATED',
+    },
+    202: {
+        description: 'Accepted',
+        constant: 'ACCEPTED',
+    },
+    203: {
+        description: 'Non Authoritative Information',
+        constant: 'NON_AUTHORITATIVE_INFORMATION',
+    },
+    204: {
+        description: 'No Content',
+        constant: 'NO_CONTENT',
+    },
+    205: {
+        description: 'Reset Content',
+        constant: 'RESET_CONTENT',
+    },
+    206: {
+        description: 'Partial Content',
+        constant: 'PARTIAL_CONTENT',
+    },
+    207: {
+        description: 'Multi-Status',
+        constant: 'MULTI_STATUS',
+    },
+    300: {
+        description: 'Multiple Choices',
+        constant: 'MULTIPLE_CHOICES',
+    },
+    301: {
+        description: 'Moved Permanently',
+        constant: 'MOVED_PERMANENTLY',
+    },
+    302: {
+        description: 'Moved Temporarily',
+        constant: 'MOVED_TEMPORARILY',
+    },
+    303: {
+        description: 'See Other',
+        constant: 'SEE_OTHER',
+    },
+    304: {
+        description: 'Not Modified',
+        constant: 'NOT_MODIFIED',
+    },
+    305: {
+        description: 'Use Proxy',
+        constant: 'USE_PROXY',
+    },
+    307: {
+        description: 'Temporary Redirect',
+        constant: 'TEMPORARY_REDIRECT',
+    },
+    308: {
+        description: 'Permanent Redirect',
+        constant: 'PERMANENT_REDIRECT',
+    },
+    400: {
+        description: 'Bad Request',
+        constant: 'BAD_REQUEST',
+    },
+    401: {
+        description: 'Unauthorized',
+        constant: 'UNAUTHORIZED',
+    },
+    402: {
+        description: 'Payment Required',
+        constant: 'PAYMENT_REQUIRED',
+    },
+    403: {
+        description: 'Forbidden',
+        constant: 'FORBIDDEN',
+    },
+    404: {
+        description: 'Not Found',
+        constant: 'NOT_FOUND',
+    },
+    405: {
+        description: 'Method Not Allowed',
+        constant: 'METHOD_NOT_ALLOWED',
+    },
+    406: {
+        description: 'Not Acceptable',
+        constant: 'NOT_ACCEPTABLE',
+    },
+    407: {
+        description: 'Proxy Authentication Required',
+        constant: 'PROXY_AUTHENTICATION_REQUIRED',
+    },
+    408: {
+        description: 'Request Timeout',
+        constant: 'REQUEST_TIMEOUT',
+    },
+    409: {
+        description: 'Conflict',
+        constant: 'CONFLICT',
+    },
+    410: {
+        description: 'Gone',
+        constant: 'GONE',
+    },
+    411: {
+        description: 'Length Required',
+        constant: 'LENGTH_REQUIRED',
+    },
+    412: {
+        description: 'Precondition Failed',
+        constant: 'PRECONDITION_FAILED',
+    },
+    413: {
+        description: 'Request Entity Too Large',
+        constant: 'REQUEST_ENTITY_TOO_LARGE',
+    },
+    414: {
+        description: 'Request-URI Too Long',
+        constant: 'REQUEST_URI_TOO_LONG',
+    },
+    415: {
+        description: 'Unsupported Media Type',
+        constant: 'UNSUPPORTED_MEDIA_TYPE',
+    },
+    416: {
+        description: 'Requested Range Not Satisfiable',
+        constant: 'REQUESTED_RANGE_NOT_SATISFIABLE',
+    },
+    417: {
+        description: 'Expectation Failed',
+        constant: 'EXPECTATION_FAILED',
+    },
+    418: {
+        description: "I'm a teapot",
+        constant: "I'M_A_TEAPOT",
+    },
+    419: {
+        description: 'Insufficient Space on Resource',
+        constant: 'INSUFFICIENT_SPACE_ON_RESOURCE',
+    },
+    420: {
+        description: 'Method Failure',
+        constant: 'METHOD_FAILURE',
+    },
+    422: {
+        description: 'Unprocessable Entity',
+        constant: 'UNPROCESSABLE_ENTITY',
+    },
+    423: {
+        description: 'Locked',
+        constant: 'LOCKED',
+    },
+    424: {
+        description: 'Failed Dependency',
+        constant: 'FAILED_DEPENDENCY',
+    },
+    428: {
+        description: 'Precondition Required',
+        constant: 'PRECONDITION_REQUIRED',
+    },
+    429: {
+        description: 'Too Many Requests',
+        constant: 'TOO_MANY_REQUESTS',
+    },
+    431: {
+        description: 'Request Header Fields Too Large',
+        constant: 'REQUEST_HEADER_FIELDS_TOO_LARGE',
+    },
+    451: {
+        description: 'Unavailable For Legal Reasons',
+        constant: 'UNAVAILABLE_FOR_LEGAL_REASONS',
+    },
+    500: {
+        description: 'Internal Server Error',
+        constant: 'INTERNAL_SERVER_ERROR',
+    },
+    501: {
+        description: 'Not Implemented',
+        constant: 'NOT_IMPLEMENTED',
+    },
+    502: {
+        description: 'Bad Gateway',
+        constant: 'BAD_GATEWAY',
+    },
+    503: {
+        description: 'Service Unavailable',
+        constant: 'SERVICE_UNAVAILABLE',
+    },
+    504: {
+        description: 'Gateway Timeout',
+        constant: 'GATEWAY_TIMEOUT',
+    },
+    505: {
+        description: 'HTTP Version Not Supported',
+        constant: 'HTTP_VERSION_NOT_SUPPORTED',
+    },
+    507: {
+        description: 'Insufficient Storage',
+        constant: 'INSUFFICIENT_STORAGE',
+    },
+    511: {
+        description: 'Network Authentication Required',
+        constant: 'NETWORK_AUTHENTICATION_REQUIRED',
+    },
+};

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

@@ -0,0 +1,30 @@
+/**
+ * @param {string} key - The translation key
+ * @param {object} data - The translation data
+ * @returns {string} - The translated
+ */
+export function i18n(key: string, data: object): string;
+export namespace i18n {
+    const _translations: {};
+    const _messageFormatter: MessageFormat;
+}
+/**
+ * @param {string} lang - Translation language code
+ */
+export function setLanguage(lang: string): void;
+/**
+ * @returns {string} - Translation language code
+ */
+export function getLanguage(): string;
+/**
+ * @param {string} lang - Translation language code
+ * @param {object} translations - Translation values by key
+ * @param {object} label - Lang label
+ */
+export function addTranslations(lang: string, translations: object, label: object): void;
+/**
+ * @returns {object} - All defined languages (key: human name and value: code)
+ */
+export function getAvailableLanguages(): object;
+export function loadDefaultTranslations(): Promise<void>;
+import MessageFormat = require("messageformat");

package/dist/src/lib/i18n.js

@@ -0,0 +1,93 @@
+/*
+ * 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 'whatwg-fetch';
+/**
+ * @param {string} key - The translation key
+ * @param {object} data - The translation data
+ * @returns {string} - The translated
+ */
+export function i18n(key, data) {
+    const translation = getTranslation(key);
+    if (translation == null) {
+        return 'unknown';
+    }
+    if (data) {
+        const msg = i18n._messageFormatter.compile(translation);
+        return msg(data);
+    }
+    return translation;
+}
+/**
+ * @param {string} key - The translation key
+ * @returns {null|string|function} - The translation string or function
+ */
+function getTranslation(key) {
+    try {
+        return key.split('.').reduce((prev, curr) => prev && prev[curr], i18n._translations[i18n._lang]);
+    }
+    catch (e) {
+        return null;
+    }
+}
+// Init private translation storage
+i18n._translations = {};
+const MessageFormat = require('messageformat');
+i18n._messageFormatter = new MessageFormat(i18n._lang);
+/**
+ * @param {string} lang - Translation language code
+ */
+export function setLanguage(lang) {
+    i18n._lang = lang;
+}
+/**
+ * @returns {string} - Translation language code
+ */
+export function getLanguage() {
+    return i18n._lang;
+}
+/**
+ * @param {string} lang - Translation language code
+ * @param {object} translations - Translation values by key
+ * @param {object} label - Lang label
+ */
+export function addTranslations(lang, translations, label) {
+    i18n._translations[lang] = { ...{ LANGUAGE: label }, ...translations };
+}
+/**
+ * @returns {object} - All defined languages (key: human name and value: code)
+ */
+export function getAvailableLanguages() {
+    const availableLanguages = {};
+    for (const lang in i18n._translations) {
+        const { LANGUAGE } = i18n._translations[lang];
+        availableLanguages[LANGUAGE] = lang;
+    }
+    return availableLanguages;
+}
+export function loadDefaultTranslations() {
+    setLanguage('en');
+    return fetch(`i18n/${i18n._lang}.json`)
+        .then((response) => {
+        return response.json();
+    })
+        .then((translations) => {
+        addTranslations(i18n._lang, translations);
+    })
+        .catch((ex) => {
+        // eslint-disable-next-line no-console
+        console.error('[ui-components] loadDefaultTranslations - parsing failed ', ex);
+    });
+}

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

@@ -0,0 +1,12 @@
+export function getVersion(item: any): any;
+export function getTitle(item: any): any;
+export function getPicture(item: any): any;
+export function getBackground(item: any): any;
+export function getStates(item: any): any;
+export function getLabels(item: any): any;
+export function getRating(item: any): any;
+export function getEntrypoints(item: any): any;
+export function getDescription(item: any): any;
+export function getOwner(item: any): any;
+export function getNbApisInView(item: any): any;
+export function getPictureDisplayName(item: any): any;

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.d.ts

@@ -0,0 +1,42 @@
+export function validateName(name: any): boolean;
+export function parseRaw(rawInput?: string): {
+    variables: {
+        key: string;
+        value: any;
+    }[];
+    errors: ({
+        type: number;
+        pos: {
+            line: any;
+            column: any;
+        };
+        key?: undefined;
+    } | {
+        type: number;
+        key: string;
+        pos: {
+            line: any;
+            column: any;
+        };
+    })[];
+};
+export function toNameEqualsValueString(variables: any, options?: {}): any;
+export function toNameValueObject(variables: any): {};
+/**
+ * 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: RegExp;
+export namespace ERROR_TYPES {
+    const INVALID_NAME: number;
+    const DUPLICATED_NAME: number;
+    const INVALID_LINE: number;
+    const INVALID_VALUE: number;
+}

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.d.ts

@@ -0,0 +1,5 @@
+export function isCodemirror(control: any): any;
+export function isObject(control: any): boolean;
+export function isComplexArray(control: any): boolean;
+export function canInline(schema: any): boolean;
+export function canGrid(schema: any): boolean;