@gravitee/ui-components 3.25.3 → 3.25.4

package/src/organisms/gv-properties.js

@@ -44,656 +44,818 @@ import { empty } from '../styles/empty';
  *
  * @cssprop {Length} [--gv-properties-table--colmg=0.2rem] - Table cells margin
  */
-
 export class GvProperties extends KeyboardElement(LitElement) {
-  static get properties() {
-    return {
-      dynamicPropertySchema: {
-        type: Object
-      },
-      properties: {
-        type: Array
-      },
-      _properties: {
-        type: Array,
-        attribute: false
-      },
-      provider: {
-        type: Object
-      },
-      providers: {
-        type: Array
-      },
-      _propertySchemaForm: {
-        type: Object,
-        attribute: false
-      },
-      expert: {
-        type: Boolean
-      },
-      _formattedErrors: {
-        type: Array,
-        attributes: false
-      },
-      _filter: {
-        type: String
-      },
-      _paginationData: {
-        type: Object,
-        attribute: false
-      },
-      _pageSize: {
-        type: Number,
-        attribute: false
-      },
-      _newItem: {
-        type: Object,
-        attribute: false
-      },
-      _providerDocumentation: {
-        type: Boolean,
-        attribute: false
-      },
-      _showDocumentation: {
-        type: Boolean,
-        attribute: false
-      },
-      _textRows: {
-        type: Number,
-        attribute: false
-      },
-      readonly: {
-        type: Boolean,
-        reflect: true
-      },
-      encryptable: {
-        type: Boolean,
-        reflect: true
-      }
-    };
-  }
-
-  constructor() {
-    super();
-    this.properties = [];
-    this.types = [];
-    this.provider = {};
-    this._currentResource = null;
-    this._formattedErrors = [];
-    this._showDocumentation = true;
-    this._newItem = {
-      key: '',
-      value: '',
-      _new: true
-    };
-    this._pageSize = 10;
-    this._textRows = 10;
-    this._pageSizes = [5, 10, 25, 50, 100];
-    this._errors = [];
-  }
-
-  onKeyboard() {
-    if (this.isPressed(KEYS.Esc)) {
-      this._onClosePropertySchemaForm();
-    }
-
-    if (this.isPressed(KEYS.Shift, KEYS.Ctrl, KEYS.Space)) {
-      const search = this.shadowRoot.querySelector('#search-property');
-
-      if (search) {
-        search.focus();
-      }
-    }
-  }
-
-  set properties(properties) {
-    this._properties = properties.sort((a, b) => a.key.localeCompare(b.key)).map(property => {
-      if (property.encrypted) {
-        property.encryptable = true;
-      }
-
-      return property;
-    });
-  }
-
-  get properties() {
-    return this._properties;
-  }
-
-  _getResizableViews() {
-    return this.shadowRoot.querySelector('gv-resizable-views');
-  }
-
-  _maximizeTopView() {
-    const views = this._getResizableViews();
-
-    if (views) {
-      views.maximizeTop(95, 5);
-    }
-  }
-
-  _maximizeBottomView() {
-    const views = this._getResizableViews();
-
-    if (views) {
-      views.resize(30, 70);
-    }
-  }
-
-  _splitMainViews() {
-    const views = this._getResizableViews();
-
-    if (views) {
-      views.split();
-    }
-  }
-
-  _isNewLineTable(line) {
-    return line._new === true;
-  }
-
-  _onInputNew(name, event) {
-    const target = event.target;
-    this._newItem[name] = event.detail;
-    const {
-      errors
-    } = parseRaw(toNameEqualsValueString([...this.properties, this._newItem]));
-    this._errors = errors;
-    setTimeout(() => {
-      const btn = this.shadowRoot.querySelector('gv-button#add-property');
-
-      if (errors.length > 0 || this._disabledNewLine(this._newItem)) {
-        btn.setAttribute('disabled', true);
-      } else {
-        btn.removeAttribute('disabled');
-      }
-
-      if (name === 'key') {
-        if (errors.length === 0) {
-          target.removeAttribute('invalid');
-          target.setAttribute('valid', true);
-        } else {
-          target.removeAttribute('valid');
-          target.setAttribute('invalid', true);
-        }
-      }
-    }, 0);
-  }
-
-  _onInput() {
-    dispatchCustomEvent(this, 'change', {
-      properties: this.properties
-    });
-  }
-
-  _onSwitchEncrypted(item) {
-    if (item.encrypted === true) {
-      item.value = '';
-      item.encrypted = false;
-      item.encryptionWarning = i18n('gv-properties.infos.overwrite-encryption');
-      this.requestUpdate();
-    }
-
-    dispatchCustomEvent(this, 'switch-encrypted', {
-      properties: this.properties
-    });
-  }
-
-  _addProperty(item) {
-    delete item._new;
-    this.properties = [item, ...this._properties];
-    this._newItem = {
-      key: '',
-      value: '',
-      _new: true,
-      encryptable: false,
-      encrypted: false
-    };
-    dispatchCustomEvent(this, 'change', {
-      properties: this.properties
-    });
-  }
-
-  _removeProperty(item) {
-    this._properties = this._properties.filter(property => property.key !== item.key);
-    dispatchCustomEvent(this, 'change', {
-      properties: this.properties
-    });
-  }
-
-  _disabledNewLine(item) {
-    return item.key == null || item.value == null || item.key.trim() === '' || item.value.trim() === '';
-  }
-
-  _submitExpertMode() {
-    if (this.expert) {
-      this.properties = this._handleExpertModeInput(this.shadowRoot.querySelector('#expert-input').value);
-    }
-  }
-
-  _onExpertModeTextInput({
-    detail
-  }) {
-    this._handleExpertModeInput(detail);
-  }
-
-  _handleExpertModeInput(expertModeInputString) {
-    let allProperties = this._properties;
-    const providerEnabled = this.provider && this.provider.enabled;
-    const dynamicProperties = allProperties.filter(prop => providerEnabled && prop.dynamic);
-    const encryptedProperties = allProperties.filter(prop => prop.encrypted);
-    const allPropertiesString = `${expertModeInputString}\n${toNameEqualsValueString(dynamicProperties)}\n${toNameEqualsValueString(encryptedProperties)}`;
-    const {
-      errors
-    } = parseRaw(allPropertiesString);
-    this._errors = errors;
-
-    if (errors.length === 0) {
-      const {
-        variables
-      } = parseRaw(expertModeInputString);
-      allProperties = [...variables, ...dynamicProperties, ...encryptedProperties];
-      dispatchCustomEvent(this, 'change', {
-        properties: allProperties
-      });
-    }
-
-    return allProperties;
-  }
-
-  _onSubmitPropertyForm({
-    detail
-  }) {
-    const provider = detail.values;
-    dispatchCustomEvent(this, 'save-provider', {
-      provider
-    });
-    this.requestUpdate();
-  }
-
-  submit() {
-    if (this.expert) {
-      this._submitExpertMode();
-    } else {
-      this._onSubmit();
-    }
-  }
-
-  _onSubmit() {
-    const invalidControls = [...this.shadowRoot.querySelectorAll('form .control')].find(control => control.invalid);
-
-    if (invalidControls == null) {
-      this._addProperty(this._newItem);
-    }
-  }
-
-  _onConfigureDynamicProperties() {
-    if (this.dynamicPropertySchema == null) {
-      // dynamicPropertySchema has been introduced to ensure backward compatibility with old versions. If no schema is provided a default schema will be used.
-      const providersTitleMap = this.providers.reduce((map, provider) => {
-        map[provider.id] = provider.key;
-        return map;
-      }, {});
-      const providersEnum = Object.keys(providersTitleMap);
-      this.dynamicPropertySchema = {
-        properties: {
-          enabled: {
-            type: 'boolean',
-            title: 'Enabled',
-            description: ' This service is requiring an API deployment. Do not forget to deploy API to start dynamic-properties service.'
-          },
-          schedule: {
-            type: 'string',
-            title: 'Schedule',
-            'x-schema-form': {
-              'cron-expression': true
+    static get properties() {
+        return {
+            dynamicPropertySchema: { type: Object },
+            properties: { type: Array },
+            _properties: { type: Array, attribute: false },
+            provider: { type: Object },
+            providers: { type: Array },
+            _propertySchemaForm: { type: Object, attribute: false },
+            expert: { type: Boolean },
+            _formattedErrors: { type: Array, attributes: false },
+            _filter: { type: String },
+            _paginationData: { type: Object, attribute: false },
+            _pageSize: { type: Number, attribute: false },
+            _newItem: { type: Object, attribute: false },
+            _providerDocumentation: { type: Boolean, attribute: false },
+            _showDocumentation: { type: Boolean, attribute: false },
+            _textRows: { type: Number, attribute: false },
+            readonly: { type: Boolean, reflect: true },
+            encryptable: { type: Boolean, reflect: true },
+        };
+    }
+    constructor() {
+        super();
+        this.properties = [];
+        this.types = [];
+        this.provider = {};
+        this._currentResource = null;
+        this._formattedErrors = [];
+        this._showDocumentation = true;
+        this._newItem = { key: '', value: '', _new: true };
+        this._pageSize = 10;
+        this._textRows = 10;
+        this._pageSizes = [5, 10, 25, 50, 100];
+        this._errors = [];
+    }
+    onKeyboard() {
+        if (this.isPressed(KEYS.Esc)) {
+            this._onClosePropertySchemaForm();
+        }
+        if (this.isPressed(KEYS.Shift, KEYS.Ctrl, KEYS.Space)) {
+            const search = this.shadowRoot.querySelector('#search-property');
+            if (search) {
+                search.focus();
             }
-          },
-          provider: {
-            type: 'string',
-            title: 'Provider type',
-            enum: providersEnum,
-            default: providersEnum[0],
-            'x-schema-form': {
-              titleMap: providersTitleMap
+        }
+    }
+    set properties(properties) {
+        this._properties = properties
+            .sort((a, b) => a.key.localeCompare(b.key))
+            .map((property) => {
+            if (property.encrypted) {
+                property.encryptable = true;
             }
-          }
-        },
-        required: ['schedule', 'provider']
-      };
-    }
-
-    const defaultProvider = this.providers[0];
-    this._propertySchemaForm = {
-      properties: { ...this.dynamicPropertySchema.properties,
-        configuration: defaultProvider.schema
-      },
-      required: this.dynamicPropertySchema.required
-    };
-    this._providerDocumentation = defaultProvider.documentation;
-
-    this._maximizeBottomView();
-  }
-
-  _onClosePropertySchemaForm() {
-    this._propertySchemaForm = null;
-
-    this._maximizeTopView();
-  }
-
-  _onSearchProperty({
-    detail
-  }) {
-    this._filter = detail;
-
-    this._onClosePropertySchemaForm();
-  }
-
-  _onClearProperty() {
-    this._filter = null;
-
-    this._onClosePropertySchemaForm();
-  }
-
-  get _errors() {
-    return this._formattedErrors;
-  }
-
-  set _errors(rawErrors) {
-    this._formattedErrors = rawErrors.map(({
-      type,
-      key,
-      pos
-    }) => {
-      if (type === ERROR_TYPES.INVALID_NAME) {
-        return {
-          line: pos.line,
-          msg: i18n('gv-properties.errors.invalid-key', {
-            key
-          })
+            return property;
+        });
+    }
+    get properties() {
+        return this._properties;
+    }
+    _getResizableViews() {
+        return this.shadowRoot.querySelector('gv-resizable-views');
+    }
+    _maximizeTopView() {
+        const views = this._getResizableViews();
+        if (views) {
+            views.maximizeTop(95, 5);
+        }
+    }
+    _maximizeBottomView() {
+        const views = this._getResizableViews();
+        if (views) {
+            views.resize(30, 70);
+        }
+    }
+    _splitMainViews() {
+        const views = this._getResizableViews();
+        if (views) {
+            views.split();
+        }
+    }
+    _isNewLineTable(line) {
+        return line._new === true;
+    }
+    _onInputNew(name, event) {
+        const target = event.target;
+        this._newItem[name] = event.detail;
+        const { errors } = parseRaw(toNameEqualsValueString([...this.properties, this._newItem]));
+        this._errors = errors;
+        setTimeout(() => {
+            const btn = this.shadowRoot.querySelector('gv-button#add-property');
+            if (errors.length > 0 || this._disabledNewLine(this._newItem)) {
+                btn.setAttribute('disabled', true);
+            }
+            else {
+                btn.removeAttribute('disabled');
+            }
+            if (name === 'key') {
+                if (errors.length === 0) {
+                    target.removeAttribute('invalid');
+                    target.setAttribute('valid', true);
+                }
+                else {
+                    target.removeAttribute('valid');
+                    target.setAttribute('invalid', true);
+                }
+            }
+        }, 0);
+    }
+    _onInput() {
+        dispatchCustomEvent(this, 'change', { properties: this.properties });
+    }
+    _onSwitchEncrypted(item) {
+        if (item.encrypted === true) {
+            item.value = '';
+            item.encrypted = false;
+            item.encryptionWarning = i18n('gv-properties.infos.overwrite-encryption');
+            this.requestUpdate();
+        }
+        dispatchCustomEvent(this, 'switch-encrypted', { properties: this.properties });
+    }
+    _addProperty(item) {
+        delete item._new;
+        this.properties = [item, ...this._properties];
+        this._newItem = { key: '', value: '', _new: true, encryptable: false, encrypted: false };
+        dispatchCustomEvent(this, 'change', { properties: this.properties });
+    }
+    _removeProperty(item) {
+        this._properties = this._properties.filter((property) => property.key !== item.key);
+        dispatchCustomEvent(this, 'change', { properties: this.properties });
+    }
+    _disabledNewLine(item) {
+        return item.key == null || item.value == null || item.key.trim() === '' || item.value.trim() === '';
+    }
+    _submitExpertMode() {
+        if (this.expert) {
+            this.properties = this._handleExpertModeInput(this.shadowRoot.querySelector('#expert-input').value);
+        }
+    }
+    _onExpertModeTextInput({ detail }) {
+        this._handleExpertModeInput(detail);
+    }
+    _handleExpertModeInput(expertModeInputString) {
+        let allProperties = this._properties;
+        const providerEnabled = this.provider && this.provider.enabled;
+        const dynamicProperties = allProperties.filter((prop) => providerEnabled && prop.dynamic);
+        const encryptedProperties = allProperties.filter((prop) => prop.encrypted);
+        const allPropertiesString = `${expertModeInputString}\n${toNameEqualsValueString(dynamicProperties)}\n${toNameEqualsValueString(encryptedProperties)}`;
+        const { errors } = parseRaw(allPropertiesString);
+        this._errors = errors;
+        if (errors.length === 0) {
+            const { variables } = parseRaw(expertModeInputString);
+            allProperties = [...variables, ...dynamicProperties, ...encryptedProperties];
+            dispatchCustomEvent(this, 'change', { properties: allProperties });
+        }
+        return allProperties;
+    }
+    _onSubmitPropertyForm({ detail }) {
+        const provider = detail.values;
+        dispatchCustomEvent(this, 'save-provider', { provider });
+        this.requestUpdate();
+    }
+    submit() {
+        if (this.expert) {
+            this._submitExpertMode();
+        }
+        else {
+            this._onSubmit();
+        }
+    }
+    _onSubmit() {
+        const invalidControls = [...this.shadowRoot.querySelectorAll('form .control')].find((control) => control.invalid);
+        if (invalidControls == null) {
+            this._addProperty(this._newItem);
+        }
+    }
+    _onConfigureDynamicProperties() {
+        if (this.dynamicPropertySchema == null) {
+            // dynamicPropertySchema has been introduced to ensure backward compatibility with old versions. If no schema is provided a default schema will be used.
+            const providersTitleMap = this.providers.reduce((map, provider) => {
+                map[provider.id] = provider.key;
+                return map;
+            }, {});
+            const providersEnum = Object.keys(providersTitleMap);
+            this.dynamicPropertySchema = {
+                properties: {
+                    enabled: {
+                        type: 'boolean',
+                        title: 'Enabled',
+                        description: ' This service is requiring an API deployment. Do not forget to deploy API to start dynamic-properties service.',
+                    },
+                    schedule: {
+                        type: 'string',
+                        title: 'Schedule',
+                        'x-schema-form': {
+                            'cron-expression': true,
+                        },
+                    },
+                    provider: {
+                        type: 'string',
+                        title: 'Provider type',
+                        enum: providersEnum,
+                        default: providersEnum[0],
+                        'x-schema-form': {
+                            titleMap: providersTitleMap,
+                        },
+                    },
+                },
+                required: ['schedule', 'provider'],
+            };
+        }
+        const defaultProvider = this.providers[0];
+        this._propertySchemaForm = {
+            properties: { ...this.dynamicPropertySchema.properties, configuration: defaultProvider.schema },
+            required: this.dynamicPropertySchema.required,
         };
-      }
+        this._providerDocumentation = defaultProvider.documentation;
+        this._maximizeBottomView();
+    }
+    _onClosePropertySchemaForm() {
+        this._propertySchemaForm = null;
+        this._maximizeTopView();
+    }
+    _onSearchProperty({ detail }) {
+        this._filter = detail;
+        this._onClosePropertySchemaForm();
+    }
+    _onClearProperty() {
+        this._filter = null;
+        this._onClosePropertySchemaForm();
+    }
+    get _errors() {
+        return this._formattedErrors;
+    }
+    set _errors(rawErrors) {
+        this._formattedErrors = rawErrors.map(({ type, key, pos }) => {
+            if (type === ERROR_TYPES.INVALID_NAME) {
+                return {
+                    line: pos.line,
+                    msg: i18n('gv-properties.errors.invalid-key', { key }),
+                };
+            }
+            if (type === ERROR_TYPES.DUPLICATED_NAME) {
+                return {
+                    line: pos.line,
+                    msg: i18n('gv-properties.errors.duplicated-key', { key }),
+                };
+            }
+            if (type === ERROR_TYPES.INVALID_LINE) {
+                return {
+                    line: pos.line,
+                    msg: i18n('gv-properties.errors.invalid-line'),
+                };
+            }
+            if (type === ERROR_TYPES.INVALID_VALUE) {
+                return {
+                    line: pos.line,
+                    msg: i18n('gv-properties.errors.invalid-value'),
+                };
+            }
+            return { line: '?', msg: i18n('gv-properties.errors.unknown') };
+        });
+    }
+    _renderErrors(withLine = false) {
+        if (this._formattedErrors.length > 0) {
+            return html `<div class="${classMap({ 'add-form-error': true, 'add-form-error_expert': this.expert })}">
+        <div></div>
+        <div class="error-list">
+          ${this._formattedErrors.map(({ line, msg }) => html `
+              <gv-input-message
+                >${withLine ? html `<strong .innerHTML="${i18n('gv-properties.errors.line')} ${line}:&nbsp;"></strong>` : ''}
+                <span .innerHTML="${msg}"></span
+              ></gv-input-message>
+            `)}
+        </div>
+      </div>`;
+        }
+        return html ``;
+    }
+    _renderTable() {
+        const providerEnabled = this.provider && this.provider.enabled;
+        if (this.expert) {
+            this._computeTextRows();
+            const staticProperties = providerEnabled ? this._properties.filter((prop) => !(providerEnabled && prop.dynamic)) : this._properties;
+            const expertProperties = staticProperties.filter((prop) => !prop.encrypted);
+            const content = expertProperties.map((prop) => `${prop.key}="${prop.value}"`).join('\n');
+            return html `<gv-text
+          id="expert-input"
+          placeholder="${i18n('gv-properties.placeholder.input')}"
+          @gv-text:input="${this._onExpertModeTextInput}"
+          .value="${content}"
+          ?readonly="${this.readonly}"
+          .rows="${this._textRows}"
+        ></gv-text>
+        ${this._renderErrors(true)}`;
+        }
+        else {
+            const options = {
+                data: [
+                    {
+                        field: 'dynamic',
+                        label: 'Dynamic',
+                        width: '40px',
+                        type: (item) => (item.dynamic && providerEnabled ? 'gv-icon' : 'div'),
+                        attributes: {
+                            shape: (item) => (item.dynamic && providerEnabled ? 'code:time-schedule' : ''),
+                            title: (item) => (item.dynamic && providerEnabled ? 'Dynamic properties service is actually in running' : ''),
+                            style: 'justify-content: center; align-items: center; height: 100%;',
+                        },
+                    },
+                    {
+                        field: 'key',
+                        label: 'Key',
+                        type: 'gv-input',
+                        attributes: {
+                            clipboard: true,
+                            placeholder: i18n('gv-properties.placeholder.key'),
+                            name: 'key',
+                            required: true,
+                            readonly: this.readonly,
+                        },
+                    },
+                    {
+                        field: 'value',
+                        label: 'Value',
+                        type: 'gv-input',
+                        attributes: {
+                            name: 'value',
+                            placeholder: 'Property value',
+                            required: true,
+                            readonly: this.readonly,
+                            disabled: (item) => (item.dynamic && providerEnabled) || item.encrypted,
+                            type: (item) => (item.encrypted ? 'password' : 'text'),
+                            title: (item) => (item.encrypted ? i18n('gv-properties.infos.encrypted-value') : ''),
+                            description: (item) => item.encryptionWarning,
+                            icon: null,
+                            'ongv-input:input': this._onInput.bind(this),
+                        },
+                    },
+                ],
+            };
+            if (this.encryptable === true) {
+                options.data.push({
+                    field: 'encryptable',
+                    type: 'gv-switch',
+                    style: '--gv-switch--ta: right;',
+                    width: '105px',
+                    attributes: {
+                        description: i18n('gv-properties.encrypted-toggle'),
+                        required: true,
+                        readonly: this.readonly,
+                        disabled: (item) => item.dynamic && providerEnabled,
+                        'ongv-switch:input': this._onSwitchEncrypted.bind(this),
+                        style: 'display: inline-flex; font-size: 12px; height: 40px;',
+                    },
+                });
+            }
+            if (this.readonly !== true) {
+                options.data.push({
+                    type: 'gv-button',
+                    width: '40px',
+                    attributes: {
+                        'ongv-button:click': (item, event, target) => this._removeProperty(item, target),
+                        title: 'Remove',
+                        disabled: (item) => item.dynamic && providerEnabled,
+                        danger: true,
+                        outlined: true,
+                        icon: 'home:trash',
+                    },
+                });
+            }
+            const filteredProperties = this._filter != null
+                ? this._properties.filter((prop) => {
+                    return (prop.key.toLowerCase() + prop.value.toLowerCase()).includes(this._filter);
+                })
+                : this._properties;
+            let properties = [...filteredProperties];
+            if (this._paginationData) {
+                this._paginationData.last = Math.ceil(filteredProperties.length / this._pageSize);
+                this._paginationData.total = filteredProperties.length;
+                this._paginationData.total_pages = Math.ceil(filteredProperties.length / this._pageSize);
+                const index = (this._paginationData.current_page - 1) * this._pageSize;
+                properties = [...filteredProperties].splice(index, this._pageSize);
+            }
+            const addPropertyFormGridClass = this.encryptable ? 'add-form-grid-with-encrypted-toggle' : 'add-form-grid';
+            const addPropertyForm = this.readonly !== true
+                ? html `<form id="add-property-form" class="add-form ${addPropertyFormGridClass}" @submit="${this._onSubmit}">
+                <div></div>
+                <gv-input
+                  class="control"
+                  placeholder="${i18n('gv-properties.placeholder.key')}"
+                  required
+                  @gv-input:input="${this._onInputNew.bind(this, 'key')}"
+                  value="${this._newItem.key}"
+                ></gv-input>
+                <gv-input
+                  class="control"
+                  placeholder="${i18n('gv-properties.placeholder.value')}"
+                  required
+                  @gv-input:input="${this._onInputNew.bind(this, 'value')}"
+                  .value="${this._newItem.value}"
+                ></gv-input>
+                ${this.encryptable
+                    ? html ` <gv-switch
+                      class="control"
+                      required
+                      description="${i18n('gv-properties.encrypted-toggle')}"
+                      @gv-switch:input="${this._onInputNew.bind(this, 'encryptable')}"
+                      .value="${this._newItem.encryptable}"
+                    ></gv-switch>`
+                    : ''}
+                <gv-button
+                  id="add-property"
+                  icon="code:plus"
+                  outlined
+                  disabled
+                  @gv-button:click="${this._addProperty.bind(this, this._newItem)}"
+                  title="${i18n('gv-properties.add')}"
+                ></gv-button>
+              </form>
+              ${this._renderErrors()}
+              <hr />`
+                : '';
+            return html ` ${addPropertyForm}
+        <gv-table .options="${options}" .items="${properties}" noheader nosort order="key" rowheight="57px"></gv-table>`;
+        }
+    }
+    _onChangeMode({ detail }) {
+        this._submitExpertMode();
+        this.expert = detail;
+        this._errors = [];
+        this._newItem = { key: '', value: '', _new: true };
+        this._onClosePropertySchemaForm();
+    }
+    _onPaginate({ detail }) {
+        this._paginationData.current_page = detail.page;
+        this._onClosePropertySchemaForm();
+        this.requestUpdate();
+    }
+    updated(props) {
+        if (props.has('_properties') || props.has('_pageSize')) {
+            this._paginationData = {
+                first: 1,
+                last: Math.ceil(this._properties.length / this._pageSize),
+                total: this._properties.length,
+                current_page: 1,
+                total_pages: Math.ceil(this._properties.length / this._pageSize),
+            };
+        }
+    }
+    _onChangePageSize({ detail }) {
+        this._pageSize = Number(detail).valueOf();
+        this._onClosePropertySchemaForm();
+    }
+    _renderTableForm() {
+        return html `<div class="container">
+      <div class="header">
+        <div class="title">Manage global properties <span>(${this._properties ? this._properties.length : 0})</span></div>
+        <gv-switch
+          small
+          .description="${this.expert ? 'Expert' : 'Simple'}"
+          .value="${this.expert}"
+          @gv-switch:input="${this._onChangeMode}"
+        ></gv-switch>
+        <gv-input
+          id="search-property"
+          placeholder="Filter properties (Shift + Ctrl + Space)"
+          type="search"
+          small
+          class="search-input"
+          .disabled="${this.expert}"
+          @gv-input:input="${this._onSearchProperty}"
+          @gv-input:clear="${this._onClearProperty}"
+        ></gv-input>
+        <gv-select
+          class="page-size__select"
+          @gv-select:input="${this._onChangePageSize}"
+          small
+          .options="${this._pageSizes}"
+          .value="${this._pageSize}"
+          .disabled="${this.expert || this._paginationData == null}"
+        ></gv-select>
+        <gv-pagination
+          @gv-pagination:paginate="${this._onPaginate}"
+          .disabled="${this.expert || this._paginationData == null}"
+          .data="${this._paginationData}"
+          widget
+        ></gv-pagination>
+      </div>
+      <div class="content"><div class="form-content">${this._renderTable()}</div></div>
+    </div>`;
+    }
+    _fetchDocumentation() {
+        this._showDocumentation = true;
+    }
+    _hideDocumentation() {
+        this._showDocumentation = false;
+    }
+    get dirty() {
+        const form = this.shadowRoot.querySelector('gv-schema-form');
+        return form && form.dirty;
+    }
+    confirm() {
+        const form = this.shadowRoot.querySelector('gv-schema-form');
+        if (form) {
+            return form.confirm().then(() => this._onClosePropertySchemaForm());
+        }
+        return Promise.resolve();
+    }
+    _renderForm() {
+        return html `<gv-schema-form
+      slot="top"
+      scrollable
+      .schema="${this._propertySchemaForm}"
+      .values="${this.provider}"
+      .icon="design:edit"
+      has-header
+      ?readonly="${this.readonly}"
+      @gv-schema-form:submit="${this._onSubmitPropertyForm}"
+    >
+      <div slot="title" class="properties-title">Configure dynamic properties</div>
+      <gv-button
+        slot="header-left"
+        icon="general:close"
+        outlined
+        small
+        @gv-button:click="${this._onClosePropertySchemaForm}"
+        title="Close (esc)"
+      ></gv-button>
+      <gv-button
+        slot="header-left"
+        icon="home:book"
+        ?disabled="${this._showDocumentation}"
+        outlined
+        small
+        @gv-button:click="${this._fetchDocumentation}"
+        title="Open documentation"
+      ></gv-button>
+    </gv-schema-form>`;
+    }
+    _renderBottom() {
+        if (this._propertySchemaForm && this._showDocumentation) {
+            return html `<gv-resizable-views no-overflow direction="horizontal">
+        ${this._renderForm()}
+        <gv-documentation
+          slot="bottom"
+          .text="${this._providerDocumentation}"
+          @gv-documentation:close="${this._hideDocumentation}"
+        ></gv-documentation>
+      </gv-resizable-views>`;
+        }
+        else if (this._propertySchemaForm) {
+            return this._renderForm();
+        }
+        else {
+            return html `<div class="properties-bottom-container">${this._renderDynamicConfiguration()}</div>`;
+        }
+    }
+    _renderDynamicConfiguration() {
+        const hasDynamicConfiguration = this.provider && this.provider.enabled;
+        let configureAction = '';
+        if (hasDynamicConfiguration || this.readonly !== true) {
+            configureAction = html `<gv-button
+        icon="tools:tools"
+        @gv-button:click="${this._onConfigureDynamicProperties}"
+        outlined
+        .disabled="${this.expert}"
+        >Configure dynamic properties</gv-button
+      >`;
+        }
+        if (hasDynamicConfiguration) {
+            return html `<div class="properties-message">
+          Dynamic properties service is actually in <code>running</code> state and run with cron expression
+          <code>${this.provider.schedule}</code> using <code>${this.provider.provider}</code> provider.
+        </div>
+        ${configureAction}`;
+        }
+        else if (this.readonly) {
+            return html `<div class="empty">No dynamic properties service configured</div>`;
+        }
+        else {
+            return configureAction;
+        }
+    }
+    _onMove() {
+        this._computeTextRows();
+    }
+    _computeTextRows() {
+        const parent = this.shadowRoot.querySelector('.content');
+        if (parent) {
+            const { height } = parent.getBoundingClientRect();
+            // --gv-text--lh=30px
+            this._textRows = Math.round(Math.round(height - 20) / 30) - 2;
+        }
+    }
+    render() {
+        if (this.providers && this.providers.length > 0) {
+            return html `<div class="properties">
+        <gv-resizable-views no-overflow @gv-resizable-views:move="${this._onMove}" @gv-resizable-views:resize="${this._onMove}">
+          <div slot="top" class="box">${this._renderTableForm()}</div>
+          <div slot="bottom">${this._renderBottom()}</div>
+        </gv-resizable-views>
+      </div>`;
+        }
+        else {
+            return html `<div class="properties">
+        <div class="table-box">${this._renderTableForm()}</div>
+      </div>`;
+        }
+    }
+    static get styles() {
+        return [
+            empty,
+            // language=CSS
+            css `
+        :host {
+          box-sizing: border-box;
+          height: 100%;
+          width: 100%;
+          display: block;
+        }
 
-      if (type === ERROR_TYPES.DUPLICATED_NAME) {
-        return {
-          line: pos.line,
-          msg: i18n('gv-properties.errors.duplicated-key', {
-            key
-          })
-        };
-      }
+        .properties {
+          display: flex;
+          height: 100%;
+          width: 100%;
+        }
 
-      if (type === ERROR_TYPES.INVALID_LINE) {
-        return {
-          line: pos.line,
-          msg: i18n('gv-properties.errors.invalid-line')
-        };
-      }
+        gv-resizable-views {
+          height: 100%;
+          width: 100%;
+        }
 
-      if (type === ERROR_TYPES.INVALID_VALUE) {
-        return {
-          line: pos.line,
-          msg: i18n('gv-properties.errors.invalid-value')
-        };
-      }
-
-      return {
-        line: '?',
-        msg: i18n('gv-properties.errors.unknown')
-      };
-    });
-  }
-
-  _renderErrors(withLine = false) {
-    if (this._formattedErrors.length > 0) {
-      return html`<div class="${classMap({
-        'add-form-error': true,
-        'add-form-error_expert': this.expert
-      })}"> <div></div> <div class="error-list"> ${this._formattedErrors.map(({
-        line,
-        msg
-      }) => html` <gv-input-message>${withLine ? html`<strong .innerHTML="${i18n('gv-properties.errors.line')} ${line}:&nbsp;"></strong>` : ''} <span .innerHTML="${msg}"></span></gv-input-message> `)} </div> </div>`;
-    }
-
-    return html``;
-  }
-
-  _renderTable() {
-    const providerEnabled = this.provider && this.provider.enabled;
-
-    if (this.expert) {
-      this._computeTextRows();
-
-      const staticProperties = providerEnabled ? this._properties.filter(prop => !(providerEnabled && prop.dynamic)) : this._properties;
-      const expertProperties = staticProperties.filter(prop => !prop.encrypted);
-      const content = expertProperties.map(prop => `${prop.key}="${prop.value}"`).join('\n');
-      return html`<gv-text id="expert-input" placeholder="${i18n('gv-properties.placeholder.input')}" @gv-text:input="${this._onExpertModeTextInput}" .value="${content}" ?readonly="${this.readonly}" .rows="${this._textRows}"></gv-text> ${this._renderErrors(true)}`;
-    } else {
-      const options = {
-        data: [{
-          field: 'dynamic',
-          label: 'Dynamic',
-          width: '40px',
-          type: item => item.dynamic && providerEnabled ? 'gv-icon' : 'div',
-          attributes: {
-            shape: item => item.dynamic && providerEnabled ? 'code:time-schedule' : '',
-            title: item => item.dynamic && providerEnabled ? 'Dynamic properties service is actually in running' : '',
-            style: 'justify-content: center; align-items: center; height: 100%;'
-          }
-        }, {
-          field: 'key',
-          label: 'Key',
-          type: 'gv-input',
-          attributes: {
-            clipboard: true,
-            placeholder: i18n('gv-properties.placeholder.key'),
-            name: 'key',
-            required: true,
-            readonly: this.readonly
-          }
-        }, {
-          field: 'value',
-          label: 'Value',
-          type: 'gv-input',
-          attributes: {
-            name: 'value',
-            placeholder: 'Property value',
-            required: true,
-            readonly: this.readonly,
-            disabled: item => item.dynamic && providerEnabled || item.encrypted,
-            type: item => item.encrypted ? 'password' : 'text',
-            title: item => item.encrypted ? i18n('gv-properties.infos.encrypted-value') : '',
-            description: item => item.encryptionWarning,
-            icon: null,
-            'ongv-input:input': this._onInput.bind(this)
-          }
-        }]
-      };
-
-      if (this.encryptable === true) {
-        options.data.push({
-          field: 'encryptable',
-          type: 'gv-switch',
-          style: '--gv-switch--ta: right;',
-          width: '105px',
-          attributes: {
-            description: i18n('gv-properties.encrypted-toggle'),
-            required: true,
-            readonly: this.readonly,
-            disabled: item => item.dynamic && providerEnabled,
-            'ongv-switch:input': this._onSwitchEncrypted.bind(this),
-            style: 'display: inline-flex; font-size: 12px; height: 40px;'
-          }
-        });
-      }
-
-      if (this.readonly !== true) {
-        options.data.push({
-          type: 'gv-button',
-          width: '40px',
-          attributes: {
-            'ongv-button:click': (item, event, target) => this._removeProperty(item, target),
-            title: 'Remove',
-            disabled: item => item.dynamic && providerEnabled,
-            danger: true,
-            outlined: true,
-            icon: 'home:trash'
-          }
-        });
-      }
-
-      const filteredProperties = this._filter != null ? this._properties.filter(prop => {
-        return (prop.key.toLowerCase() + prop.value.toLowerCase()).includes(this._filter);
-      }) : this._properties;
-      let properties = [...filteredProperties];
-
-      if (this._paginationData) {
-        this._paginationData.last = Math.ceil(filteredProperties.length / this._pageSize);
-        this._paginationData.total = filteredProperties.length;
-        this._paginationData.total_pages = Math.ceil(filteredProperties.length / this._pageSize);
-        const index = (this._paginationData.current_page - 1) * this._pageSize;
-        properties = [...filteredProperties].splice(index, this._pageSize);
-      }
+        gv-schema-form {
+          margin: 0;
+        }
 
-      const addPropertyFormGridClass = this.encryptable ? 'add-form-grid-with-encrypted-toggle' : 'add-form-grid';
-      const addPropertyForm = this.readonly !== true ? html`<form id="add-property-form" class="add-form ${addPropertyFormGridClass}" @submit="${this._onSubmit}"> <div></div> <gv-input class="control" placeholder="${i18n('gv-properties.placeholder.key')}" required @gv-input:input="${this._onInputNew.bind(this, 'key')}" value="${this._newItem.key}"></gv-input> <gv-input class="control" placeholder="${i18n('gv-properties.placeholder.value')}" required @gv-input:input="${this._onInputNew.bind(this, 'value')}" .value="${this._newItem.value}"></gv-input> ${this.encryptable ? html` <gv-switch class="control" required description="${i18n('gv-properties.encrypted-toggle')}" @gv-switch:input="${this._onInputNew.bind(this, 'encryptable')}" .value="${this._newItem.encryptable}"></gv-switch>` : ''} <gv-button id="add-property" icon="code:plus" outlined disabled="disabled" @gv-button:click="${this._addProperty.bind(this, this._newItem)}" title="${i18n('gv-properties.add')}"></gv-button> </form> ${this._renderErrors()} <hr>` : '';
-      return html` ${addPropertyForm} <gv-table .options="${options}" .items="${properties}" noheader nosort order="key" rowheight="57px"></gv-table>`;
-    }
-  }
-
-  _onChangeMode({
-    detail
-  }) {
-    this._submitExpertMode();
+        .table-box {
+          width: 100%;
+          border-left: 1px solid #bfbfbf;
+          display: flex;
+        }
 
-    this.expert = detail;
-    this._errors = [];
-    this._newItem = {
-      key: '',
-      value: '',
-      _new: true
-    };
+        gv-table {
+          height: auto;
+          flex: 1;
+          margin-top: 10px;
+          margin-right: 50px;
+          --gv-table-rows--ov: none;
+          --gv-table--colmg: var(--gv-properties-table--colmg, 0.2rem);
+          --gv-table-cell--d: inline;
+          --gv-table-row--ai: flex-start;
+          --gv-table-row--ac: flex-start;
+          --gv-table-hover--bgc: var(--gv-theme-neutral-color-lightest);
+        }
 
-    this._onClosePropertySchemaForm();
-  }
+        .properties-title {
+          text-transform: uppercase;
+          letter-spacing: 0.2rem;
+        }
 
-  _onPaginate({
-    detail
-  }) {
-    this._paginationData.current_page = detail.page;
+        .properties-bottom-container {
+          display: flex;
+          justify-content: center;
+          align-items: center;
+          height: 100%;
+          flex-direction: column;
+        }
 
-    this._onClosePropertySchemaForm();
+        .header {
+          border-bottom: 1px solid #d9d9d9;
+          display: flex;
+          min-height: 45px;
+          align-items: center;
+          margin-bottom: 0.5rem;
+          padding: 0 0.5rem;
+        }
 
-    this.requestUpdate();
-  }
+        .header .title {
+          color: #28444f;
+          font-size: 18px;
+          display: flex;
+          align-items: flex-end;
+          flex: 1;
+        }
 
-  updated(props) {
-    if (props.has('_properties') || props.has('_pageSize')) {
-      this._paginationData = {
-        first: 1,
-        last: Math.ceil(this._properties.length / this._pageSize),
-        total: this._properties.length,
-        current_page: 1,
-        total_pages: Math.ceil(this._properties.length / this._pageSize)
-      };
-    }
-  }
+        .header .title span {
+          font-size: 12px;
+          margin-left: 8px;
+          opacity: 0.7;
+        }
 
-  _onChangePageSize({
-    detail
-  }) {
-    this._pageSize = Number(detail).valueOf();
+        .box {
+          position: absolute;
+          display: flex;
+          flex-direction: column;
+          width: 100%;
+          top: 0;
+          bottom: 0;
+          left: 0;
+        }
 
-    this._onClosePropertySchemaForm();
-  }
+        .container {
+          flex-grow: 1;
 
-  _renderTableForm() {
-    return html`<div class="container"> <div class="header"> <div class="title">Manage global properties <span>(${this._properties ? this._properties.length : 0})</span></div> <gv-switch small .description="${this.expert ? 'Expert' : 'Simple'}" .value="${this.expert}" @gv-switch:input="${this._onChangeMode}"></gv-switch> <gv-input id="search-property" placeholder="Filter properties (Shift + Ctrl + Space)" type="search" small class="search-input" .disabled="${this.expert}" @gv-input:input="${this._onSearchProperty}" @gv-input:clear="${this._onClearProperty}"></gv-input> <gv-select class="page-size__select" @gv-select:input="${this._onChangePageSize}" small .options="${this._pageSizes}" .value="${this._pageSize}" .disabled="${this.expert || this._paginationData == null}"></gv-select> <gv-pagination @gv-pagination:paginate="${this._onPaginate}" .disabled="${this.expert || this._paginationData == null}" .data="${this._paginationData}" widget></gv-pagination> </div> <div class="content"><div class="form-content">${this._renderTable()}</div></div> </div>`;
-  }
+          display: flex;
+          flex-direction: column;
 
-  _fetchDocumentation() {
-    this._showDocumentation = true;
-  }
+          /* for Firefox */
+          min-height: 0;
+          height: 100%;
+        }
 
-  _hideDocumentation() {
-    this._showDocumentation = false;
-  }
+        .content {
+          background: white;
+          flex-grow: 1;
 
-  get dirty() {
-    const form = this.shadowRoot.querySelector('gv-schema-form');
-    return form && form.dirty;
-  }
+          overflow: auto;
 
-  confirm() {
-    const form = this.shadowRoot.querySelector('gv-schema-form');
+          /* for Firefox */
+          min-height: 0;
+          padding: 0.5rem;
 
-    if (form) {
-      return form.confirm().then(() => this._onClosePropertySchemaForm());
-    }
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+        }
 
-    return Promise.resolve();
-  }
+        gv-text {
+          --gv-text--fz: 20px;
+          --gv-text--lh: 25px;
+        }
 
-  _renderForm() {
-    return html`<gv-schema-form slot="top" scrollable .schema="${this._propertySchemaForm}" .values="${this.provider}" .icon="design:edit" has-header ?readonly="${this.readonly}" @gv-schema-form:submit="${this._onSubmitPropertyForm}"> <div slot="title" class="properties-title">Configure dynamic properties</div> <gv-button slot="header-left" icon="general:close" outlined small @gv-button:click="${this._onClosePropertySchemaForm}" title="Close (esc)"></gv-button> <gv-button slot="header-left" icon="home:book" ?disabled="${this._showDocumentation}" outlined small @gv-button:click="${this._fetchDocumentation}" title="Open documentation"></gv-button> </gv-schema-form>`;
-  }
+        gv-switch {
+          --gv-switch--ta: right;
+        }
 
-  _renderBottom() {
-    if (this._propertySchemaForm && this._showDocumentation) {
-      return html`<gv-resizable-views no-overflow direction="horizontal"> ${this._renderForm()} <gv-documentation slot="bottom" .text="${this._providerDocumentation}" @gv-documentation:close="${this._hideDocumentation}"></gv-documentation> </gv-resizable-views>`;
-    } else if (this._propertySchemaForm) {
-      return this._renderForm();
-    } else {
-      return html`<div class="properties-bottom-container">${this._renderDynamicConfiguration()}</div>`;
-    }
-  }
+        .header gv-input {
+          margin: 0 1rem;
+        }
 
-  _renderDynamicConfiguration() {
-    const hasDynamicConfiguration = this.provider && this.provider.enabled;
-    let configureAction = '';
+        .add-form,
+        .add-form-error {
+          display: grid;
+          margin: auto 50px auto 0;
+          box-sizing: border-box;
+        }
 
-    if (hasDynamicConfiguration || this.readonly !== true) {
-      configureAction = html`<gv-button icon="tools:tools" @gv-button:click="${this._onConfigureDynamicProperties}" outlined .disabled="${this.expert}">Configure dynamic properties</gv-button>`;
-    }
+        .add-form {
+          column-gap: var(--gv-properties-table--colmg, 0.2rem);
+          border-right: solid thick transparent;
+          height: 50px;
+        }
 
-    if (hasDynamicConfiguration) {
-      return html`<div class="properties-message"> Dynamic properties service is actually in <code>running</code> state and run with cron expression <code>${this.provider.schedule}</code> using <code>${this.provider.provider}</code> provider. </div> ${configureAction}`;
-    } else if (this.readonly) {
-      return html`<div class="empty">No dynamic properties service configured</div>`;
-    } else {
-      return configureAction;
-    }
-  }
+        .add-form gv-input,
+        gv-button,
+        gv-switch {
+          margin: auto 0;
+        }
 
-  _onMove() {
-    this._computeTextRows();
-  }
+        .add-form gv-switch {
+          font-size: 12px;
+        }
 
-  _computeTextRows() {
-    const parent = this.shadowRoot.querySelector('.content');
+        .add-form-grid {
+          grid-template-columns: 40px auto auto 40px;
+        }
 
-    if (parent) {
-      const {
-        height
-      } = parent.getBoundingClientRect(); // --gv-text--lh=30px
+        .add-form-grid-with-encrypted-toggle {
+          grid-template-columns: 40px auto auto 105px 40px;
+        }
 
-      this._textRows = Math.round(Math.round(height - 20) / 30) - 2;
-    }
-  }
+        .add-form-error_expert {
+          display: flex;
+        }
 
-  render() {
-    if (this.providers && this.providers.length > 0) {
-      return html`<div class="properties"> <gv-resizable-views no-overflow @gv-resizable-views:move="${this._onMove}" @gv-resizable-views:resize="${this._onMove}"> <div slot="top" class="box">${this._renderTableForm()}</div> <div slot="bottom">${this._renderBottom()}</div> </gv-resizable-views> </div>`;
-    } else {
-      return html`<div class="properties"> <div class="table-box">${this._renderTableForm()}</div> </div>`;
-    }
-  }
+        .add-form-error {
+          grid-template-columns: 40px 1fr;
+        }
+
+        code {
+          color: var(--gv-theme-color-warning-dark, #f57c00);
+        }
 
-  static get styles() {
-    return [empty, // language=CSS
-    css`:host{box-sizing:border-box;height:100%;width:100%;display:block}.properties{display:flex;height:100%;width:100%}gv-resizable-views{height:100%;width:100%}gv-schema-form{margin:0}.table-box{width:100%;border-left:1px solid #bfbfbf;display:flex}gv-table{height:auto;flex:1;margin-top:10px;margin-right:50px;--gv-table-rows--ov:none;--gv-table--colmg:var(--gv-properties-table--colmg, 0.2rem);--gv-table-cell--d:inline;--gv-table-row--ai:flex-start;--gv-table-row--ac:flex-start;--gv-table-hover--bgc:var(--gv-theme-neutral-color-lightest)}.properties-title{text-transform:uppercase;letter-spacing:.2rem}.properties-bottom-container{display:flex;justify-content:center;align-items:center;height:100%;flex-direction:column}.header{border-bottom:1px solid #d9d9d9;display:flex;min-height:45px;align-items:center;margin-bottom:.5rem;padding:0 .5rem}.header .title{color:#28444f;font-size:18px;display:flex;align-items:flex-end;flex:1}.header .title span{font-size:12px;margin-left:8px;opacity:.7}.box{position:absolute;display:flex;flex-direction:column;width:100%;top:0;bottom:0;left:0}.container{flex-grow:1;display:flex;flex-direction:column;min-height:0;height:100%}.content{background:#fff;flex-grow:1;overflow:auto;min-height:0;padding:.5rem;display:flex;flex-direction:column;align-items:center}gv-text{--gv-text--fz:20px;--gv-text--lh:25px}gv-switch{--gv-switch--ta:right}.header gv-input{margin:0 1rem}.add-form,.add-form-error{display:grid;margin:auto 50px auto 0;box-sizing:border-box}.add-form{column-gap:var(--gv-properties-table--colmg,.2rem);border-right:solid thick transparent;height:50px}.add-form gv-input,gv-button,gv-switch{margin:auto 0}.add-form gv-switch{font-size:12px}.add-form-grid{grid-template-columns:40px auto auto 40px}.add-form-grid-with-encrypted-toggle{grid-template-columns:40px auto auto 105px 40px}.add-form-error_expert{display:flex}.add-form-error{grid-template-columns:40px 1fr}code{color:var(--gv-theme-color-warning-dark,#f57c00)}.form-content{display:flex;flex-direction:column;width:100%}.properties-message{margin-bottom:.5rem;font-size:14px}.page-size__select{max-width:50px}.search-input{width:300px}hr{background-color:var(--gv-theme-neutral-color);border:0;width:100%;height:2px}`];
-  }
+        .form-content {
+          display: flex;
+          flex-direction: column;
+          width: 100%;
+        }
 
+        .properties-message {
+          margin-bottom: 0.5rem;
+          font-size: 14px;
+        }
+
+        .page-size__select {
+          max-width: 50px;
+        }
+
+        .search-input {
+          width: 300px;
+        }
+
+        hr {
+          background-color: var(--gv-theme-neutral-color);
+          border: 0;
+          width: 100%;
+          height: 2px;
+        }
+      `,
+        ];
+    }
 }
 window.customElements.define('gv-properties', GvProperties);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["./node_modules/@gravitee/ui-components/organisms/gv-properties.js"],"names":["css","html","LitElement","dispatchCustomEvent","ERROR_TYPES","parseRaw","toNameEqualsValueString","i18n","classMap","KeyboardElement","KEYS","empty","GvProperties","properties","dynamicPropertySchema","type","Object","Array","_properties","attribute","provider","providers","_propertySchemaForm","expert","Boolean","_formattedErrors","attributes","_filter","String","_paginationData","_pageSize","Number","_newItem","_providerDocumentation","_showDocumentation","_textRows","readonly","reflect","encryptable","constructor","types","_currentResource","key","value","_new","_pageSizes","_errors","onKeyboard","isPressed","Esc","_onClosePropertySchemaForm","Shift","Ctrl","Space","search","shadowRoot","querySelector","focus","sort","a","b","localeCompare","map","property","encrypted","_getResizableViews","_maximizeTopView","views","maximizeTop","_maximizeBottomView","resize","_splitMainViews","split","_isNewLineTable","line","_onInputNew","name","event","target","detail","errors","setTimeout","btn","length","_disabledNewLine","setAttribute","removeAttribute","_onInput","_onSwitchEncrypted","item","encryptionWarning","requestUpdate","_addProperty","_removeProperty","filter","trim","_submitExpertMode","_handleExpertModeInput","_onExpertModeTextInput","expertModeInputString","allProperties","providerEnabled","enabled","dynamicProperties","prop","dynamic","encryptedProperties","allPropertiesString","variables","_onSubmitPropertyForm","values","submit","_onSubmit","invalidControls","querySelectorAll","find","control","invalid","_onConfigureDynamicProperties","providersTitleMap","reduce","id","providersEnum","keys","title","description","schedule","enum","default","titleMap","required","defaultProvider","configuration","schema","documentation","_onSearchProperty","_onClearProperty","rawErrors","pos","INVALID_NAME","msg","DUPLICATED_NAME","INVALID_LINE","INVALID_VALUE","_renderErrors","withLine","_renderTable","_computeTextRows","staticProperties","expertProperties","content","join","options","data","field","label","width","shape","style","clipboard","placeholder","disabled","icon","bind","push","danger","outlined","filteredProperties","toLowerCase","includes","last","Math","ceil","total","total_pages","index","current_page","splice","addPropertyFormGridClass","addPropertyForm","_onChangeMode","_onPaginate","page","updated","props","has","first","_onChangePageSize","valueOf","_renderTableForm","_fetchDocumentation","_hideDocumentation","dirty","form","confirm","then","Promise","resolve","_renderForm","_renderBottom","_renderDynamicConfiguration","hasDynamicConfiguration","configureAction","_onMove","parent","height","getBoundingClientRect","round","render","styles","window","customElements","define"],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2015 The Gravitee team (http://gravitee.io)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { css, html, LitElement } from 'lit';\n\nimport './gv-schema-form';\nimport './gv-resizable-views';\nimport '../molecules/gv-table';\nimport '../atoms/gv-button';\nimport '../atoms/gv-input';\nimport '../atoms/gv-icon';\nimport '../atoms/gv-text';\nimport '../atoms/gv-input-message';\nimport '../atoms/gv-select';\nimport { dispatchCustomEvent } from '../lib/events';\nimport { ERROR_TYPES, parseRaw, toNameEqualsValueString } from '../lib/properties';\nimport { i18n } from '../lib/i18n';\nimport { classMap } from 'lit/directives/class-map';\nimport { KeyboardElement, KEYS } from '../mixins/keyboard-element';\nimport { empty } from '../styles/empty';\n\n/**\n * A component to manage properties\n *\n * @fires gv-properties:change - When list of properties change\n * @fires gv-properties:save-provider - When user validates provider configuration\n * @fires gv-properties:switch-encrypted - When user switches encryption toggle\n *\n * @attr {Array} properties - Array of Properties {key, value, dynamic?}\n * @attr {Object} provider - Configuration of provider\n * @attr {Array} providers - List of available providers (only http for the moment)\n * @attr {Boolean} expert - For display expert mode by default\n * @attr {Boolean} encryptable - To display the 'encrypted' toggle on each property\n *\n * @cssprop {Length} [--gv-properties-table--colmg=0.2rem] - Table cells margin\n */\nexport class GvProperties extends KeyboardElement(LitElement) {\n  static get properties() {\n    return {\n      dynamicPropertySchema: { type: Object },\n      properties: { type: Array },\n      _properties: { type: Array, attribute: false },\n      provider: { type: Object },\n      providers: { type: Array },\n      _propertySchemaForm: { type: Object, attribute: false },\n      expert: { type: Boolean },\n      _formattedErrors: { type: Array, attributes: false },\n      _filter: { type: String },\n      _paginationData: { type: Object, attribute: false },\n      _pageSize: { type: Number, attribute: false },\n      _newItem: { type: Object, attribute: false },\n      _providerDocumentation: { type: Boolean, attribute: false },\n      _showDocumentation: { type: Boolean, attribute: false },\n      _textRows: { type: Number, attribute: false },\n      readonly: { type: Boolean, reflect: true },\n      encryptable: { type: Boolean, reflect: true },\n    };\n  }\n\n  constructor() {\n    super();\n    this.properties = [];\n    this.types = [];\n    this.provider = {};\n    this._currentResource = null;\n    this._formattedErrors = [];\n    this._showDocumentation = true;\n    this._newItem = { key: '', value: '', _new: true };\n    this._pageSize = 10;\n    this._textRows = 10;\n    this._pageSizes = [5, 10, 25, 50, 100];\n    this._errors = [];\n  }\n\n  onKeyboard() {\n    if (this.isPressed(KEYS.Esc)) {\n      this._onClosePropertySchemaForm();\n    }\n    if (this.isPressed(KEYS.Shift, KEYS.Ctrl, KEYS.Space)) {\n      const search = this.shadowRoot.querySelector('#search-property');\n      if (search) {\n        search.focus();\n      }\n    }\n  }\n\n  set properties(properties) {\n    this._properties = properties\n      .sort((a, b) => a.key.localeCompare(b.key))\n      .map((property) => {\n        if (property.encrypted) {\n          property.encryptable = true;\n        }\n        return property;\n      });\n  }\n\n  get properties() {\n    return this._properties;\n  }\n\n  _getResizableViews() {\n    return this.shadowRoot.querySelector('gv-resizable-views');\n  }\n\n  _maximizeTopView() {\n    const views = this._getResizableViews();\n    if (views) {\n      views.maximizeTop(95, 5);\n    }\n  }\n\n  _maximizeBottomView() {\n    const views = this._getResizableViews();\n    if (views) {\n      views.resize(30, 70);\n    }\n  }\n\n  _splitMainViews() {\n    const views = this._getResizableViews();\n    if (views) {\n      views.split();\n    }\n  }\n\n  _isNewLineTable(line) {\n    return line._new === true;\n  }\n\n  _onInputNew(name, event) {\n    const target = event.target;\n    this._newItem[name] = event.detail;\n    const { errors } = parseRaw(toNameEqualsValueString([...this.properties, this._newItem]));\n    this._errors = errors;\n    setTimeout(() => {\n      const btn = this.shadowRoot.querySelector('gv-button#add-property');\n      if (errors.length > 0 || this._disabledNewLine(this._newItem)) {\n        btn.setAttribute('disabled', true);\n      } else {\n        btn.removeAttribute('disabled');\n      }\n      if (name === 'key') {\n        if (errors.length === 0) {\n          target.removeAttribute('invalid');\n          target.setAttribute('valid', true);\n        } else {\n          target.removeAttribute('valid');\n          target.setAttribute('invalid', true);\n        }\n      }\n    }, 0);\n  }\n\n  _onInput() {\n    dispatchCustomEvent(this, 'change', { properties: this.properties });\n  }\n\n  _onSwitchEncrypted(item) {\n    if (item.encrypted === true) {\n      item.value = '';\n      item.encrypted = false;\n      item.encryptionWarning = i18n('gv-properties.infos.overwrite-encryption');\n      this.requestUpdate();\n    }\n    dispatchCustomEvent(this, 'switch-encrypted', { properties: this.properties });\n  }\n\n  _addProperty(item) {\n    delete item._new;\n    this.properties = [item, ...this._properties];\n    this._newItem = { key: '', value: '', _new: true, encryptable: false, encrypted: false };\n    dispatchCustomEvent(this, 'change', { properties: this.properties });\n  }\n\n  _removeProperty(item) {\n    this._properties = this._properties.filter((property) => property.key !== item.key);\n    dispatchCustomEvent(this, 'change', { properties: this.properties });\n  }\n\n  _disabledNewLine(item) {\n    return item.key == null || item.value == null || item.key.trim() === '' || item.value.trim() === '';\n  }\n\n  _submitExpertMode() {\n    if (this.expert) {\n      this.properties = this._handleExpertModeInput(this.shadowRoot.querySelector('#expert-input').value);\n    }\n  }\n\n  _onExpertModeTextInput({ detail }) {\n    this._handleExpertModeInput(detail);\n  }\n\n  _handleExpertModeInput(expertModeInputString) {\n    let allProperties = this._properties;\n    const providerEnabled = this.provider && this.provider.enabled;\n    const dynamicProperties = allProperties.filter((prop) => providerEnabled && prop.dynamic);\n    const encryptedProperties = allProperties.filter((prop) => prop.encrypted);\n\n    const allPropertiesString = `${expertModeInputString}\\n${toNameEqualsValueString(dynamicProperties)}\\n${toNameEqualsValueString(\n      encryptedProperties,\n    )}`;\n    const { errors } = parseRaw(allPropertiesString);\n    this._errors = errors;\n    if (errors.length === 0) {\n      const { variables } = parseRaw(expertModeInputString);\n      allProperties = [...variables, ...dynamicProperties, ...encryptedProperties];\n      dispatchCustomEvent(this, 'change', { properties: allProperties });\n    }\n\n    return allProperties;\n  }\n\n  _onSubmitPropertyForm({ detail }) {\n    const provider = detail.values;\n    dispatchCustomEvent(this, 'save-provider', { provider });\n    this.requestUpdate();\n  }\n\n  submit() {\n    if (this.expert) {\n      this._submitExpertMode();\n    } else {\n      this._onSubmit();\n    }\n  }\n\n  _onSubmit() {\n    const invalidControls = [...this.shadowRoot.querySelectorAll('form .control')].find((control) => control.invalid);\n    if (invalidControls == null) {\n      this._addProperty(this._newItem);\n    }\n  }\n\n  _onConfigureDynamicProperties() {\n    if (this.dynamicPropertySchema == null) {\n      // dynamicPropertySchema has been introduced to ensure backward compatibility with old versions. If no schema is provided a default schema will be used.\n      const providersTitleMap = this.providers.reduce((map, provider) => {\n        map[provider.id] = provider.key;\n        return map;\n      }, {});\n\n      const providersEnum = Object.keys(providersTitleMap);\n      this.dynamicPropertySchema = {\n        properties: {\n          enabled: {\n            type: 'boolean',\n            title: 'Enabled',\n            description: ' This service is requiring an API deployment. Do not forget to deploy API to start dynamic-properties service.',\n          },\n          schedule: {\n            type: 'string',\n            title: 'Schedule',\n            'x-schema-form': {\n              'cron-expression': true,\n            },\n          },\n          provider: {\n            type: 'string',\n            title: 'Provider type',\n            enum: providersEnum,\n            default: providersEnum[0],\n            'x-schema-form': {\n              titleMap: providersTitleMap,\n            },\n          },\n        },\n        required: ['schedule', 'provider'],\n      };\n    }\n\n    const defaultProvider = this.providers[0];\n\n    this._propertySchemaForm = {\n      properties: { ...this.dynamicPropertySchema.properties, configuration: defaultProvider.schema },\n      required: this.dynamicPropertySchema.required,\n    };\n    this._providerDocumentation = defaultProvider.documentation;\n    this._maximizeBottomView();\n  }\n\n  _onClosePropertySchemaForm() {\n    this._propertySchemaForm = null;\n    this._maximizeTopView();\n  }\n\n  _onSearchProperty({ detail }) {\n    this._filter = detail;\n    this._onClosePropertySchemaForm();\n  }\n\n  _onClearProperty() {\n    this._filter = null;\n    this._onClosePropertySchemaForm();\n  }\n\n  get _errors() {\n    return this._formattedErrors;\n  }\n\n  set _errors(rawErrors) {\n    this._formattedErrors = rawErrors.map(({ type, key, pos }) => {\n      if (type === ERROR_TYPES.INVALID_NAME) {\n        return {\n          line: pos.line,\n          msg: i18n('gv-properties.errors.invalid-key', { key }),\n        };\n      }\n      if (type === ERROR_TYPES.DUPLICATED_NAME) {\n        return {\n          line: pos.line,\n          msg: i18n('gv-properties.errors.duplicated-key', { key }),\n        };\n      }\n      if (type === ERROR_TYPES.INVALID_LINE) {\n        return {\n          line: pos.line,\n          msg: i18n('gv-properties.errors.invalid-line'),\n        };\n      }\n      if (type === ERROR_TYPES.INVALID_VALUE) {\n        return {\n          line: pos.line,\n          msg: i18n('gv-properties.errors.invalid-value'),\n        };\n      }\n      return { line: '?', msg: i18n('gv-properties.errors.unknown') };\n    });\n  }\n\n  _renderErrors(withLine = false) {\n    if (this._formattedErrors.length > 0) {\n      return html`<div class=\"${classMap({ 'add-form-error': true, 'add-form-error_expert': this.expert })}\">\n        <div></div>\n        <div class=\"error-list\">\n          ${this._formattedErrors.map(\n            ({ line, msg }) => html`\n              <gv-input-message\n                >${withLine ? html`<strong .innerHTML=\"${i18n('gv-properties.errors.line')} ${line}:&nbsp;\"></strong>` : ''}\n                <span .innerHTML=\"${msg}\"></span\n              ></gv-input-message>\n            `,\n          )}\n        </div>\n      </div>`;\n    }\n    return html``;\n  }\n\n  _renderTable() {\n    const providerEnabled = this.provider && this.provider.enabled;\n    if (this.expert) {\n      this._computeTextRows();\n\n      const staticProperties = providerEnabled ? this._properties.filter((prop) => !(providerEnabled && prop.dynamic)) : this._properties;\n      const expertProperties = staticProperties.filter((prop) => !prop.encrypted);\n      const content = expertProperties.map((prop) => `${prop.key}=\"${prop.value}\"`).join('\\n');\n\n      return html`<gv-text\n          id=\"expert-input\"\n          placeholder=\"${i18n('gv-properties.placeholder.input')}\"\n          @gv-text:input=\"${this._onExpertModeTextInput}\"\n          .value=\"${content}\"\n          ?readonly=\"${this.readonly}\"\n          .rows=\"${this._textRows}\"\n        ></gv-text>\n        ${this._renderErrors(true)}`;\n    } else {\n      const options = {\n        data: [\n          {\n            field: 'dynamic',\n            label: 'Dynamic',\n            width: '40px',\n            type: (item) => (item.dynamic && providerEnabled ? 'gv-icon' : 'div'),\n            attributes: {\n              shape: (item) => (item.dynamic && providerEnabled ? 'code:time-schedule' : ''),\n              title: (item) => (item.dynamic && providerEnabled ? 'Dynamic properties service is actually in running' : ''),\n              style: 'justify-content: center; align-items: center; height: 100%;',\n            },\n          },\n          {\n            field: 'key',\n            label: 'Key',\n            type: 'gv-input',\n            attributes: {\n              clipboard: true,\n              placeholder: i18n('gv-properties.placeholder.key'),\n              name: 'key',\n              required: true,\n              readonly: this.readonly,\n            },\n          },\n          {\n            field: 'value',\n            label: 'Value',\n            type: 'gv-input',\n            attributes: {\n              name: 'value',\n              placeholder: 'Property value',\n              required: true,\n              readonly: this.readonly,\n              disabled: (item) => (item.dynamic && providerEnabled) || item.encrypted,\n              type: (item) => (item.encrypted ? 'password' : 'text'),\n              title: (item) => (item.encrypted ? i18n('gv-properties.infos.encrypted-value') : ''),\n              description: (item) => item.encryptionWarning,\n              icon: null,\n              'ongv-input:input': this._onInput.bind(this),\n            },\n          },\n        ],\n      };\n\n      if (this.encryptable === true) {\n        options.data.push({\n          field: 'encryptable',\n          type: 'gv-switch',\n          style: '--gv-switch--ta: right;',\n          width: '105px',\n          attributes: {\n            description: i18n('gv-properties.encrypted-toggle'),\n            required: true,\n            readonly: this.readonly,\n            disabled: (item) => item.dynamic && providerEnabled,\n            'ongv-switch:input': this._onSwitchEncrypted.bind(this),\n            style: 'display: inline-flex; font-size: 12px; height: 40px;',\n          },\n        });\n      }\n\n      if (this.readonly !== true) {\n        options.data.push({\n          type: 'gv-button',\n          width: '40px',\n          attributes: {\n            'ongv-button:click': (item, event, target) => this._removeProperty(item, target),\n            title: 'Remove',\n            disabled: (item) => item.dynamic && providerEnabled,\n            danger: true,\n            outlined: true,\n            icon: 'home:trash',\n          },\n        });\n      }\n\n      const filteredProperties =\n        this._filter != null\n          ? this._properties.filter((prop) => {\n              return (prop.key.toLowerCase() + prop.value.toLowerCase()).includes(this._filter);\n            })\n          : this._properties;\n      let properties = [...filteredProperties];\n      if (this._paginationData) {\n        this._paginationData.last = Math.ceil(filteredProperties.length / this._pageSize);\n        this._paginationData.total = filteredProperties.length;\n        this._paginationData.total_pages = Math.ceil(filteredProperties.length / this._pageSize);\n        const index = (this._paginationData.current_page - 1) * this._pageSize;\n        properties = [...filteredProperties].splice(index, this._pageSize);\n      }\n\n      const addPropertyFormGridClass = this.encryptable ? 'add-form-grid-with-encrypted-toggle' : 'add-form-grid';\n\n      const addPropertyForm =\n        this.readonly !== true\n          ? html`<form id=\"add-property-form\" class=\"add-form ${addPropertyFormGridClass}\" @submit=\"${this._onSubmit}\">\n                <div></div>\n                <gv-input\n                  class=\"control\"\n                  placeholder=\"${i18n('gv-properties.placeholder.key')}\"\n                  required\n                  @gv-input:input=\"${this._onInputNew.bind(this, 'key')}\"\n                  value=\"${this._newItem.key}\"\n                ></gv-input>\n                <gv-input\n                  class=\"control\"\n                  placeholder=\"${i18n('gv-properties.placeholder.value')}\"\n                  required\n                  @gv-input:input=\"${this._onInputNew.bind(this, 'value')}\"\n                  .value=\"${this._newItem.value}\"\n                ></gv-input>\n                ${this.encryptable\n                  ? html` <gv-switch\n                      class=\"control\"\n                      required\n                      description=\"${i18n('gv-properties.encrypted-toggle')}\"\n                      @gv-switch:input=\"${this._onInputNew.bind(this, 'encryptable')}\"\n                      .value=\"${this._newItem.encryptable}\"\n                    ></gv-switch>`\n                  : ''}\n                <gv-button\n                  id=\"add-property\"\n                  icon=\"code:plus\"\n                  outlined\n                  disabled\n                  @gv-button:click=\"${this._addProperty.bind(this, this._newItem)}\"\n                  title=\"${i18n('gv-properties.add')}\"\n                ></gv-button>\n              </form>\n              ${this._renderErrors()}\n              <hr />`\n          : '';\n\n      return html` ${addPropertyForm}\n        <gv-table .options=\"${options}\" .items=\"${properties}\" noheader nosort order=\"key\" rowheight=\"57px\"></gv-table>`;\n    }\n  }\n\n  _onChangeMode({ detail }) {\n    this._submitExpertMode();\n    this.expert = detail;\n    this._errors = [];\n    this._newItem = { key: '', value: '', _new: true };\n    this._onClosePropertySchemaForm();\n  }\n\n  _onPaginate({ detail }) {\n    this._paginationData.current_page = detail.page;\n    this._onClosePropertySchemaForm();\n    this.requestUpdate();\n  }\n\n  updated(props) {\n    if (props.has('_properties') || props.has('_pageSize')) {\n      this._paginationData = {\n        first: 1,\n        last: Math.ceil(this._properties.length / this._pageSize),\n        total: this._properties.length,\n        current_page: 1,\n        total_pages: Math.ceil(this._properties.length / this._pageSize),\n      };\n    }\n  }\n\n  _onChangePageSize({ detail }) {\n    this._pageSize = Number(detail).valueOf();\n    this._onClosePropertySchemaForm();\n  }\n\n  _renderTableForm() {\n    return html`<div class=\"container\">\n      <div class=\"header\">\n        <div class=\"title\">Manage global properties <span>(${this._properties ? this._properties.length : 0})</span></div>\n        <gv-switch\n          small\n          .description=\"${this.expert ? 'Expert' : 'Simple'}\"\n          .value=\"${this.expert}\"\n          @gv-switch:input=\"${this._onChangeMode}\"\n        ></gv-switch>\n        <gv-input\n          id=\"search-property\"\n          placeholder=\"Filter properties (Shift + Ctrl + Space)\"\n          type=\"search\"\n          small\n          class=\"search-input\"\n          .disabled=\"${this.expert}\"\n          @gv-input:input=\"${this._onSearchProperty}\"\n          @gv-input:clear=\"${this._onClearProperty}\"\n        ></gv-input>\n        <gv-select\n          class=\"page-size__select\"\n          @gv-select:input=\"${this._onChangePageSize}\"\n          small\n          .options=\"${this._pageSizes}\"\n          .value=\"${this._pageSize}\"\n          .disabled=\"${this.expert || this._paginationData == null}\"\n        ></gv-select>\n        <gv-pagination\n          @gv-pagination:paginate=\"${this._onPaginate}\"\n          .disabled=\"${this.expert || this._paginationData == null}\"\n          .data=\"${this._paginationData}\"\n          widget\n        ></gv-pagination>\n      </div>\n      <div class=\"content\"><div class=\"form-content\">${this._renderTable()}</div></div>\n    </div>`;\n  }\n\n  _fetchDocumentation() {\n    this._showDocumentation = true;\n  }\n\n  _hideDocumentation() {\n    this._showDocumentation = false;\n  }\n\n  get dirty() {\n    const form = this.shadowRoot.querySelector('gv-schema-form');\n    return form && form.dirty;\n  }\n\n  confirm() {\n    const form = this.shadowRoot.querySelector('gv-schema-form');\n    if (form) {\n      return form.confirm().then(() => this._onClosePropertySchemaForm());\n    }\n    return Promise.resolve();\n  }\n\n  _renderForm() {\n    return html`<gv-schema-form\n      slot=\"top\"\n      scrollable\n      .schema=\"${this._propertySchemaForm}\"\n      .values=\"${this.provider}\"\n      .icon=\"design:edit\"\n      has-header\n      ?readonly=\"${this.readonly}\"\n      @gv-schema-form:submit=\"${this._onSubmitPropertyForm}\"\n    >\n      <div slot=\"title\" class=\"properties-title\">Configure dynamic properties</div>\n      <gv-button\n        slot=\"header-left\"\n        icon=\"general:close\"\n        outlined\n        small\n        @gv-button:click=\"${this._onClosePropertySchemaForm}\"\n        title=\"Close (esc)\"\n      ></gv-button>\n      <gv-button\n        slot=\"header-left\"\n        icon=\"home:book\"\n        ?disabled=\"${this._showDocumentation}\"\n        outlined\n        small\n        @gv-button:click=\"${this._fetchDocumentation}\"\n        title=\"Open documentation\"\n      ></gv-button>\n    </gv-schema-form>`;\n  }\n\n  _renderBottom() {\n    if (this._propertySchemaForm && this._showDocumentation) {\n      return html`<gv-resizable-views no-overflow direction=\"horizontal\">\n        ${this._renderForm()}\n        <gv-documentation\n          slot=\"bottom\"\n          .text=\"${this._providerDocumentation}\"\n          @gv-documentation:close=\"${this._hideDocumentation}\"\n        ></gv-documentation>\n      </gv-resizable-views>`;\n    } else if (this._propertySchemaForm) {\n      return this._renderForm();\n    } else {\n      return html`<div class=\"properties-bottom-container\">${this._renderDynamicConfiguration()}</div>`;\n    }\n  }\n\n  _renderDynamicConfiguration() {\n    const hasDynamicConfiguration = this.provider && this.provider.enabled;\n\n    let configureAction = '';\n    if (hasDynamicConfiguration || this.readonly !== true) {\n      configureAction = html`<gv-button\n        icon=\"tools:tools\"\n        @gv-button:click=\"${this._onConfigureDynamicProperties}\"\n        outlined\n        .disabled=\"${this.expert}\"\n        >Configure dynamic properties</gv-button\n      >`;\n    }\n\n    if (hasDynamicConfiguration) {\n      return html`<div class=\"properties-message\">\n          Dynamic properties service is actually in <code>running</code> state and run with cron expression\n          <code>${this.provider.schedule}</code> using <code>${this.provider.provider}</code> provider.\n        </div>\n        ${configureAction}`;\n    } else if (this.readonly) {\n      return html`<div class=\"empty\">No dynamic properties service configured</div>`;\n    } else {\n      return configureAction;\n    }\n  }\n\n  _onMove() {\n    this._computeTextRows();\n  }\n\n  _computeTextRows() {\n    const parent = this.shadowRoot.querySelector('.content');\n    if (parent) {\n      const { height } = parent.getBoundingClientRect();\n      // --gv-text--lh=30px\n      this._textRows = Math.round(Math.round(height - 20) / 30) - 2;\n    }\n  }\n\n  render() {\n    if (this.providers && this.providers.length > 0) {\n      return html`<div class=\"properties\">\n        <gv-resizable-views no-overflow @gv-resizable-views:move=\"${this._onMove}\" @gv-resizable-views:resize=\"${this._onMove}\">\n          <div slot=\"top\" class=\"box\">${this._renderTableForm()}</div>\n          <div slot=\"bottom\">${this._renderBottom()}</div>\n        </gv-resizable-views>\n      </div>`;\n    } else {\n      return html`<div class=\"properties\">\n        <div class=\"table-box\">${this._renderTableForm()}</div>\n      </div>`;\n    }\n  }\n\n  static get styles() {\n    return [\n      empty,\n      // language=CSS\n      css`\n        :host {\n          box-sizing: border-box;\n          height: 100%;\n          width: 100%;\n          display: block;\n        }\n\n        .properties {\n          display: flex;\n          height: 100%;\n          width: 100%;\n        }\n\n        gv-resizable-views {\n          height: 100%;\n          width: 100%;\n        }\n\n        gv-schema-form {\n          margin: 0;\n        }\n\n        .table-box {\n          width: 100%;\n          border-left: 1px solid #bfbfbf;\n          display: flex;\n        }\n\n        gv-table {\n          height: auto;\n          flex: 1;\n          margin-top: 10px;\n          margin-right: 50px;\n          --gv-table-rows--ov: none;\n          --gv-table--colmg: var(--gv-properties-table--colmg, 0.2rem);\n          --gv-table-cell--d: inline;\n          --gv-table-row--ai: flex-start;\n          --gv-table-row--ac: flex-start;\n          --gv-table-hover--bgc: var(--gv-theme-neutral-color-lightest);\n        }\n\n        .properties-title {\n          text-transform: uppercase;\n          letter-spacing: 0.2rem;\n        }\n\n        .properties-bottom-container {\n          display: flex;\n          justify-content: center;\n          align-items: center;\n          height: 100%;\n          flex-direction: column;\n        }\n\n        .header {\n          border-bottom: 1px solid #d9d9d9;\n          display: flex;\n          min-height: 45px;\n          align-items: center;\n          margin-bottom: 0.5rem;\n          padding: 0 0.5rem;\n        }\n\n        .header .title {\n          color: #28444f;\n          font-size: 18px;\n          display: flex;\n          align-items: flex-end;\n          flex: 1;\n        }\n\n        .header .title span {\n          font-size: 12px;\n          margin-left: 8px;\n          opacity: 0.7;\n        }\n\n        .box {\n          position: absolute;\n          display: flex;\n          flex-direction: column;\n          width: 100%;\n          top: 0;\n          bottom: 0;\n          left: 0;\n        }\n\n        .container {\n          flex-grow: 1;\n\n          display: flex;\n          flex-direction: column;\n\n          /* for Firefox */\n          min-height: 0;\n          height: 100%;\n        }\n\n        .content {\n          background: white;\n          flex-grow: 1;\n\n          overflow: auto;\n\n          /* for Firefox */\n          min-height: 0;\n          padding: 0.5rem;\n\n          display: flex;\n          flex-direction: column;\n          align-items: center;\n        }\n\n        gv-text {\n          --gv-text--fz: 20px;\n          --gv-text--lh: 25px;\n        }\n\n        gv-switch {\n          --gv-switch--ta: right;\n        }\n\n        .header gv-input {\n          margin: 0 1rem;\n        }\n\n        .add-form,\n        .add-form-error {\n          display: grid;\n          margin: auto 50px auto 0;\n          box-sizing: border-box;\n        }\n\n        .add-form {\n          column-gap: var(--gv-properties-table--colmg, 0.2rem);\n          border-right: solid thick transparent;\n          height: 50px;\n        }\n\n        .add-form gv-input,\n        gv-button,\n        gv-switch {\n          margin: auto 0;\n        }\n\n        .add-form gv-switch {\n          font-size: 12px;\n        }\n\n        .add-form-grid {\n          grid-template-columns: 40px auto auto 40px;\n        }\n\n        .add-form-grid-with-encrypted-toggle {\n          grid-template-columns: 40px auto auto 105px 40px;\n        }\n\n        .add-form-error_expert {\n          display: flex;\n        }\n\n        .add-form-error {\n          grid-template-columns: 40px 1fr;\n        }\n\n        code {\n          color: var(--gv-theme-color-warning-dark, #f57c00);\n        }\n\n        .form-content {\n          display: flex;\n          flex-direction: column;\n          width: 100%;\n        }\n\n        .properties-message {\n          margin-bottom: 0.5rem;\n          font-size: 14px;\n        }\n\n        .page-size__select {\n          max-width: 50px;\n        }\n\n        .search-input {\n          width: 300px;\n        }\n\n        hr {\n          background-color: var(--gv-theme-neutral-color);\n          border: 0;\n          width: 100%;\n          height: 2px;\n        }\n      `,\n    ];\n  }\n}\n\nwindow.customElements.define('gv-properties', GvProperties);\n"]}
+//# sourceMappingURL=gv-properties.js.map