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

package/dist/src/lib/cron-expression.js

@@ -0,0 +1,176 @@
+/*
+ * 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.
+ */
+// This comes from the fact that parseInt trims characters coming
+// after digits and consider it a valid int, so `1*` becomes `1`.
+const safeParseInt = (value) => {
+    if (/^\d+$/.test(value)) {
+        return Number(value);
+    }
+    else {
+        return NaN;
+    }
+};
+const isWildcard = (value) => {
+    return value === '*';
+};
+const isQuestionMark = (value) => {
+    return value === '?';
+};
+const isInRange = (value, start, stop) => {
+    return value >= start && value <= stop;
+};
+const isValidRange = (value, start, stop) => {
+    const sides = value.split('-');
+    switch (sides.length) {
+        case 1:
+            return isWildcard(value) || isInRange(safeParseInt(value), start, stop);
+        case 2:
+            // eslint-disable-next-line no-case-declarations
+            const [small, big] = sides.map((side) => safeParseInt(side));
+            return small <= big && isInRange(small, start, stop) && isInRange(big, start, stop);
+        default:
+            return false;
+    }
+};
+const isValidStep = (value) => {
+    return value === undefined || value.search(/[^\d]/) === -1;
+};
+const validateForRange = (value, start, stop) => {
+    if (value.search(/[^\d-,/*]/) !== -1) {
+        return false;
+    }
+    const list = value.split(',');
+    return list.every((condition) => {
+        const splits = condition.split('/');
+        // Prevents `*/ * * * *` from being accepted.
+        if (condition.trim().endsWith('/')) {
+            return false;
+        }
+        // Prevents `*/*/* * * * *` from being accepted
+        if (splits.length > 2) {
+            return false;
+        }
+        // If we don't have a `/`, right will be undefined which is considered a valid step if we don't a `/`.
+        const [left, right] = splits;
+        return isValidRange(left, start, stop) && isValidStep(right);
+    });
+};
+const hasValidSeconds = (seconds) => {
+    return validateForRange(seconds, 0, 59);
+};
+const hasValidMinutes = (minutes) => {
+    return validateForRange(minutes, 0, 59);
+};
+const hasValidHours = (hours) => {
+    return validateForRange(hours, 0, 23);
+};
+const hasValidDays = (days, allowBlankDay) => {
+    return (allowBlankDay && isQuestionMark(days)) || validateForRange(days, 1, 31);
+};
+const monthAlias = {
+    jan: '1',
+    feb: '2',
+    mar: '3',
+    apr: '4',
+    may: '5',
+    jun: '6',
+    jul: '7',
+    aug: '8',
+    sep: '9',
+    oct: '10',
+    nov: '11',
+    dec: '12',
+};
+const hasValidMonths = (months, alias) => {
+    // Prevents alias to be used as steps
+    if (months.search(/\/[a-zA-Z]/) !== -1) {
+        return false;
+    }
+    if (alias) {
+        const remappedMonths = months.toLowerCase().replace(/[a-z]{3}/g, (match) => {
+            return monthAlias[match] === undefined ? match : monthAlias[match];
+        });
+        // If any invalid alias was used, it won't pass the other checks as there will be non-numeric values in the months
+        return validateForRange(remappedMonths, 1, 12);
+    }
+    return validateForRange(months, 1, 12);
+};
+const weekdaysAlias = {
+    sun: '0',
+    mon: '1',
+    tue: '2',
+    wed: '3',
+    thu: '4',
+    fri: '5',
+    sat: '6',
+};
+const hasValidWeekdays = (weekdays, alias, allowBlankDay, allowSevenAsSunday) => {
+    // If there is a question mark, checks if the allowBlankDay flag is set
+    if (allowBlankDay && isQuestionMark(weekdays)) {
+        return true;
+    }
+    else if (!allowBlankDay && isQuestionMark(weekdays)) {
+        return false;
+    }
+    // Prevents alias to be used as steps
+    if (weekdays.search(/\/[a-zA-Z]/) !== -1) {
+        return false;
+    }
+    if (alias) {
+        const remappedWeekdays = weekdays.toLowerCase().replace(/[a-z]{3}/g, (match) => {
+            return weekdaysAlias[match] === undefined ? match : weekdaysAlias[match];
+        });
+        // If any invalid alias was used, it won't pass the other checks as there will be non-numeric values in the weekdays
+        return validateForRange(remappedWeekdays, 0, allowSevenAsSunday ? 7 : 6);
+    }
+    return validateForRange(weekdays, 0, allowSevenAsSunday ? 7 : 6);
+};
+const hasCompatibleDayFormat = (days, weekdays, allowBlankDay) => {
+    return !(allowBlankDay && isQuestionMark(days) && isQuestionMark(weekdays));
+};
+const split = (cron) => {
+    return cron.trim().split(/\s+/);
+};
+const defaultOptions = {
+    alias: false,
+    seconds: false,
+    allowBlankDay: false,
+    allowSevenAsSunday: false,
+};
+export const isValidCron = (cron, options) => {
+    options = { ...defaultOptions, ...options };
+    const splits = split(cron);
+    if (splits.length > (options.seconds ? 6 : 5) || splits.length < 5) {
+        return false;
+    }
+    const checks = [];
+    if (splits.length === 6) {
+        const seconds = splits.shift();
+        if (seconds) {
+            checks.push(hasValidSeconds(seconds));
+        }
+    }
+    // We could only check the steps gradually and return false on the first invalid block,
+    // However, this won't have any performance impact so why bother for now.
+    const [minutes, hours, days, months, weekdays] = splits;
+    checks.push(hasValidMinutes(minutes));
+    checks.push(hasValidHours(hours));
+    checks.push(hasValidDays(days, options.allowBlankDay));
+    checks.push(hasValidMonths(months, options.alias));
+    checks.push(hasValidWeekdays(weekdays, options.alias, options.allowBlankDay, options.allowSevenAsSunday));
+    checks.push(hasCompatibleDayFormat(days, weekdays, options.allowBlankDay));
+    return checks.every(Boolean);
+};

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

@@ -0,0 +1 @@
+export function isInvalid(date: any, min: any, max: any, noTime?: boolean, disabledDates?: any[]): boolean;

package/dist/src/lib/date.js

@@ -0,0 +1,43 @@
+/*
+ * 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 isInvalid(date, min, max, noTime = true, disabledDates = []) {
+    if (date) {
+        if (min) {
+            const minDate = new Date(min * 1000);
+            if (noTime) {
+                minDate.setHours(0, 0);
+            }
+            minDate.setSeconds(0, 0);
+            if (date < minDate.getTime() / 1000) {
+                return true;
+            }
+        }
+        if (max) {
+            const maxDate = new Date(max * 1000);
+            if (noTime) {
+                maxDate.setHours(23, 59);
+            }
+            maxDate.setSeconds(59, 59);
+            if (date > maxDate.getTime() / 1000) {
+                return true;
+            }
+        }
+        if (disabledDates.findIndex((disabledDay) => parseInt(disabledDay, 10) === date) !== -1) {
+            return true;
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1 @@
+export function dispatchCustomEvent(node: any, suffix: any, detail: any, options?: {}): void;

package/dist/src/lib/events.js

@@ -0,0 +1,26 @@
+/*
+ * 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 dispatchCustomEvent(node, suffix, detail, options = {}) {
+    const eventName = `${node.nodeName.toLocaleLowerCase()}:${suffix}`;
+    /* global CustomEvent */
+    const event = new CustomEvent(eventName, {
+        detail,
+        bubbles: true,
+        composed: true,
+        ...options,
+    });
+    node.dispatchEvent(event);
+}

package/dist/src/lib/http-client-schema-form.d.ts

@@ -0,0 +1,68 @@
+export namespace httpClientSchemaForm {
+    export const type: string;
+    export const id: string;
+    export namespace properties {
+        namespace method {
+            export const title: string;
+            export const description: string;
+            const type_1: string;
+            export { type_1 as type };
+            const _default: string;
+            export { _default as default };
+            const _enum: string[];
+            export { _enum as enum };
+        }
+        namespace path {
+            const title_1: string;
+            export { title_1 as title };
+            const type_2: string;
+            export { type_2 as type };
+            const _default_1: string;
+            export { _default_1 as default };
+        }
+        namespace headers {
+            const type_3: string;
+            export { type_3 as type };
+            const title_2: string;
+            export { title_2 as title };
+            export namespace items {
+                const type_4: string;
+                export { type_4 as type };
+                const title_3: string;
+                export { title_3 as title };
+                export namespace properties_1 {
+                    namespace name {
+                        const title_4: string;
+                        export { title_4 as title };
+                        const type_5: string;
+                        export { type_5 as type };
+                    }
+                    namespace value {
+                        const title_5: string;
+                        export { title_5 as title };
+                        const type_6: string;
+                        export { type_6 as type };
+                    }
+                }
+                export { properties_1 as properties };
+            }
+            export const required: string[];
+        }
+        const body: {
+            title: string;
+            type: string;
+            'x-schema-form': {
+                type: string;
+                codemirrorOptions: {
+                    placeholder: string;
+                    lineWrapping: boolean;
+                    lineNumbers: boolean;
+                    allowDropFileTypes: boolean;
+                    autoCloseTags: boolean;
+                };
+            };
+        };
+    }
+    const required_1: string[];
+    export { required_1 as required };
+}

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

@@ -0,0 +1,67 @@
+/*
+ * 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 httpClientSchemaForm = {
+    type: 'object',
+    id: 'urn:jsonschema:io:gravitee:http:client',
+    properties: {
+        method: {
+            title: 'HTTP Method',
+            description: 'HTTP method to invoke the endpoint.',
+            type: 'string',
+            default: 'GET',
+            enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'CONNECT', 'OPTIONS', 'TRACE'],
+        },
+        path: {
+            title: 'Path',
+            type: 'string',
+            default: '/',
+        },
+        headers: {
+            type: 'array',
+            title: 'Request Headers',
+            items: {
+                type: 'object',
+                title: 'Header',
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string',
+                    },
+                    value: {
+                        title: 'Value',
+                        type: 'string',
+                    },
+                },
+            },
+            required: ['name', 'value'],
+        },
+        body: {
+            title: 'Request body',
+            type: 'string',
+            'x-schema-form': {
+                type: 'codemirror',
+                codemirrorOptions: {
+                    placeholder: 'Put request body here',
+                    lineWrapping: true,
+                    lineNumbers: true,
+                    allowDropFileTypes: true,
+                    autoCloseTags: true,
+                },
+            },
+        },
+    },
+    required: ['method', 'path'],
+};

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

@@ -0,0 +1,222 @@
+export const statusCode: {
+    100: {
+        description: string;
+        constant: string;
+    };
+    101: {
+        description: string;
+        constant: string;
+    };
+    102: {
+        description: string;
+        constant: string;
+    };
+    200: {
+        description: string;
+        constant: string;
+    };
+    201: {
+        description: string;
+        constant: string;
+    };
+    202: {
+        description: string;
+        constant: string;
+    };
+    203: {
+        description: string;
+        constant: string;
+    };
+    204: {
+        description: string;
+        constant: string;
+    };
+    205: {
+        description: string;
+        constant: string;
+    };
+    206: {
+        description: string;
+        constant: string;
+    };
+    207: {
+        description: string;
+        constant: string;
+    };
+    300: {
+        description: string;
+        constant: string;
+    };
+    301: {
+        description: string;
+        constant: string;
+    };
+    302: {
+        description: string;
+        constant: string;
+    };
+    303: {
+        description: string;
+        constant: string;
+    };
+    304: {
+        description: string;
+        constant: string;
+    };
+    305: {
+        description: string;
+        constant: string;
+    };
+    307: {
+        description: string;
+        constant: string;
+    };
+    308: {
+        description: string;
+        constant: string;
+    };
+    400: {
+        description: string;
+        constant: string;
+    };
+    401: {
+        description: string;
+        constant: string;
+    };
+    402: {
+        description: string;
+        constant: string;
+    };
+    403: {
+        description: string;
+        constant: string;
+    };
+    404: {
+        description: string;
+        constant: string;
+    };
+    405: {
+        description: string;
+        constant: string;
+    };
+    406: {
+        description: string;
+        constant: string;
+    };
+    407: {
+        description: string;
+        constant: string;
+    };
+    408: {
+        description: string;
+        constant: string;
+    };
+    409: {
+        description: string;
+        constant: string;
+    };
+    410: {
+        description: string;
+        constant: string;
+    };
+    411: {
+        description: string;
+        constant: string;
+    };
+    412: {
+        description: string;
+        constant: string;
+    };
+    413: {
+        description: string;
+        constant: string;
+    };
+    414: {
+        description: string;
+        constant: string;
+    };
+    415: {
+        description: string;
+        constant: string;
+    };
+    416: {
+        description: string;
+        constant: string;
+    };
+    417: {
+        description: string;
+        constant: string;
+    };
+    418: {
+        description: string;
+        constant: string;
+    };
+    419: {
+        description: string;
+        constant: string;
+    };
+    420: {
+        description: string;
+        constant: string;
+    };
+    422: {
+        description: string;
+        constant: string;
+    };
+    423: {
+        description: string;
+        constant: string;
+    };
+    424: {
+        description: string;
+        constant: string;
+    };
+    428: {
+        description: string;
+        constant: string;
+    };
+    429: {
+        description: string;
+        constant: string;
+    };
+    431: {
+        description: string;
+        constant: string;
+    };
+    451: {
+        description: string;
+        constant: string;
+    };
+    500: {
+        description: string;
+        constant: string;
+    };
+    501: {
+        description: string;
+        constant: string;
+    };
+    502: {
+        description: string;
+        constant: string;
+    };
+    503: {
+        description: string;
+        constant: string;
+    };
+    504: {
+        description: string;
+        constant: string;
+    };
+    505: {
+        description: string;
+        constant: string;
+    };
+    507: {
+        description: string;
+        constant: string;
+    };
+    511: {
+        description: string;
+        constant: string;
+    };
+};