@gravitee/ui-components 3.25.3 → 3.25.4

package/src/organisms/gv-resources.js

@@ -27,402 +27,471 @@ import { uuid } from '../lib/utils';
 import { KeyboardElement, KEYS } from '../mixins/keyboard-element';
 import { empty } from '../styles/empty';
 export class GvResources extends KeyboardElement(LitElement) {
-  static get properties() {
-    return {
-      resources: {
-        type: Array
-      },
-      _resources: {
-        type: Array,
-        attribute: false
-      },
-      types: {
-        type: Array
-      },
-      documentation: {
-        type: Object
-      },
-      _currentResource: {
-        type: Object,
-        attribute: false
-      },
-      _currentResourceLoading: {
-        type: Boolean,
-        attribute: false
-      },
-      _filter: {
-        type: String
-      },
-      readonly: {
-        type: Boolean,
-        reflect: true
-      }
-    };
-  }
-
-  constructor() {
-    super();
-    this.resources = [];
-    this.types = [];
-    this._currentResource = null;
-    this._emptymessage = 'No resource';
-  }
-
-  onKeyboard() {
-    if (this.isPressed(KEYS.Esc)) {
-      this._onCancelResourceForm();
+    static get properties() {
+        return {
+            resources: { type: Array },
+            _resources: { type: Array, attribute: false },
+            types: { type: Array },
+            documentation: { type: Object },
+            _currentResource: { type: Object, attribute: false },
+            _currentResourceLoading: { type: Boolean, attribute: false },
+            _filter: { type: String },
+            readonly: { type: Boolean, reflect: true },
+        };
     }
-
-    if (this.isPressed(KEYS.Shift, KEYS.Ctrl, KEYS.Space)) {
-      const search = this.shadowRoot.querySelector('#search-resource');
-
-      if (search) {
-        search.focus();
-      }
+    constructor() {
+        super();
+        this.resources = [];
+        this.types = [];
+        this._currentResource = null;
+        this._emptymessage = 'No resource';
     }
-  }
-
-  firstUpdated() {
-    const views = this.shadowRoot.querySelector('gv-resizable-views');
-
-    if (views != null) {
-      views.updateComplete.then(() => {
+    onKeyboard() {
+        if (this.isPressed(KEYS.Esc)) {
+            this._onCancelResourceForm();
+        }
+        if (this.isPressed(KEYS.Shift, KEYS.Ctrl, KEYS.Space)) {
+            const search = this.shadowRoot.querySelector('#search-resource');
+            if (search) {
+                search.focus();
+            }
+        }
+    }
+    firstUpdated() {
+        const views = this.shadowRoot.querySelector('gv-resizable-views');
+        if (views != null) {
+            views.updateComplete.then(() => {
+                this._maximizeTopView();
+            });
+        }
+    }
+    set resources(resources) {
+        this._resources = this._generateId(resources);
+    }
+    get resources() {
+        return this._resources;
+    }
+    _generateId(list) {
+        if (list) {
+            return list.map((e) => {
+                if (e._id == null) {
+                    e._id = uuid();
+                }
+                return e;
+            });
+        }
+        return list;
+    }
+    _getResizableViews() {
+        return this.shadowRoot.querySelector('gv-resizable-views');
+    }
+    _maximizeTopView() {
+        this._getResizableViews().resize(60, 40);
+    }
+    _maximizeBottomView() {
+        this._getResizableViews().maximizeBottom();
+    }
+    _splitMainViews() {
+        this._getResizableViews().split();
+    }
+    _onCancelResourceForm() {
+        this._currentResource = null;
+        this.documentation = null;
         this._maximizeTopView();
-      });
     }
-  }
-
-  set resources(resources) {
-    this._resources = this._generateId(resources);
-  }
-
-  get resources() {
-    return this._resources;
-  }
-
-  _generateId(list) {
-    if (list) {
-      return list.map(e => {
-        if (e._id == null) {
-          e._id = uuid();
+    _removeResource(item) {
+        this.resources = this.resources.filter((resource) => resource._id !== item._id);
+        this._onCancelResourceForm();
+        dispatchCustomEvent(this, 'change', { resources: this.resources });
+    }
+    _buildResourceSchema(resourceType) {
+        const defaultSchema = {
+            properties: {
+                name: {
+                    type: 'string',
+                    title: 'Resource name',
+                },
+            },
+            required: ['name'],
+        };
+        const schema = typeof resourceType.schema === 'string' ? JSON.parse(resourceType.schema) : resourceType.schema;
+        return {
+            properties: { ...defaultSchema.properties, ...schema.properties },
+            required: [...defaultSchema.required, ...schema.required],
+        };
+    }
+    _onCreateResource({ detail }) {
+        this._currentResourceLoading = true;
+        const defaultResourceType = this.types.find((type) => type.id === detail.id);
+        const schema = this._buildResourceSchema(defaultResourceType);
+        this._currentResource = {
+            type: defaultResourceType.id,
+            title: 'Create resource',
+            icon: 'code:plus',
+            schema,
+            values: {},
+            submitLabel: 'Add',
+            dirty: true,
+        };
+        this._maximizeBottomView();
+        this._onFetchDocumentation();
+        setTimeout(() => (this._currentResourceLoading = false), 600);
+    }
+    _onSubmitResourceForm({ detail }) {
+        delete this._currentResource._values;
+        const { type } = this._currentResource;
+        const { _id, name, ...configuration } = detail.values;
+        const resource = {
+            _id,
+            type,
+            name,
+            configuration,
+        };
+        if (detail.values._id != null) {
+            const index = this.resources.findIndex((r) => r._id === resource._id);
+            this.resources[index] = { ...this.resources[index], ...resource };
         }
-
-        return e;
-      });
+        else {
+            if (this.resources == null) {
+                this.resources = [];
+            }
+            resource._id = uuid();
+            resource.enabled = true;
+            this.resources.push(resource);
+        }
+        this._onCancelResourceForm();
+        dispatchCustomEvent(this, 'change', { resources: this.resources });
     }
-
-    return list;
-  }
-
-  _getResizableViews() {
-    return this.shadowRoot.querySelector('gv-resizable-views');
-  }
-
-  _maximizeTopView() {
-    this._getResizableViews().resize(60, 40);
-  }
-
-  _maximizeBottomView() {
-    this._getResizableViews().maximizeBottom();
-  }
-
-  _splitMainViews() {
-    this._getResizableViews().split();
-  }
-
-  _onCancelResourceForm() {
-    this._currentResource = null;
-    this.documentation = null;
-
-    this._maximizeTopView();
-  }
-
-  _removeResource(item) {
-    this.resources = this.resources.filter(resource => resource._id !== item._id);
-
-    this._onCancelResourceForm();
-
-    dispatchCustomEvent(this, 'change', {
-      resources: this.resources
-    });
-  }
-
-  _buildResourceSchema(resourceType) {
-    const defaultSchema = {
-      properties: {
-        name: {
-          type: 'string',
-          title: 'Resource name'
+    _onChangeResourceForm({ detail }) {
+        this._currentResource._values = detail.values;
+    }
+    _onResetResourceForm() {
+        delete this._currentResource._values;
+    }
+    _findResourceById(id) {
+        return this.types.find((resource) => resource.id === id);
+    }
+    // For readonly mode
+    _onSelectResource({ detail: { items } }) {
+        if (items.length > 0) {
+            this._onEditResource(items[0]);
+        }
+        else {
+            this._onCancelResourceForm();
         }
-      },
-      required: ['name']
-    };
-    const schema = typeof resourceType.schema === 'string' ? JSON.parse(resourceType.schema) : resourceType.schema;
-    return {
-      properties: { ...defaultSchema.properties,
-        ...schema.properties
-      },
-      required: [...defaultSchema.required, ...schema.required]
-    };
-  }
-
-  _onCreateResource({
-    detail
-  }) {
-    this._currentResourceLoading = true;
-    const defaultResourceType = this.types.find(type => type.id === detail.id);
-
-    const schema = this._buildResourceSchema(defaultResourceType);
-
-    this._currentResource = {
-      type: defaultResourceType.id,
-      title: 'Create resource',
-      icon: 'code:plus',
-      schema,
-      values: {},
-      submitLabel: 'Add',
-      dirty: true
-    };
-
-    this._maximizeBottomView();
-
-    this._onFetchDocumentation();
-
-    setTimeout(() => this._currentResourceLoading = false, 600);
-  }
-
-  _onSubmitResourceForm({
-    detail
-  }) {
-    delete this._currentResource._values;
-    const {
-      type
-    } = this._currentResource;
-    const {
-      _id,
-      name,
-      ...configuration
-    } = detail.values;
-    const resource = {
-      _id,
-      type,
-      name,
-      configuration
-    };
-
-    if (detail.values._id != null) {
-      const index = this.resources.findIndex(r => r._id === resource._id);
-      this.resources[index] = { ...this.resources[index],
-        ...resource
-      };
-    } else {
-      if (this.resources == null) {
-        this.resources = [];
-      }
-
-      resource._id = uuid();
-      resource.enabled = true;
-      this.resources.push(resource);
     }
-
-    this._onCancelResourceForm();
-
-    dispatchCustomEvent(this, 'change', {
-      resources: this.resources
-    });
-  }
-
-  _onChangeResourceForm({
-    detail
-  }) {
-    this._currentResource._values = detail.values;
-  }
-
-  _onResetResourceForm() {
-    delete this._currentResource._values;
-  }
-
-  _findResourceById(id) {
-    return this.types.find(resource => resource.id === id);
-  } // For readonly mode
-
-
-  _onSelectResource({
-    detail: {
-      items
+    _onEditResource(resource) {
+        const values = { ...resource, ...resource.configuration };
+        delete values.configuration;
+        const resourceType = this._findResourceById(resource.type);
+        this._currentResource = {
+            _id: resource._id,
+            title: 'Resource configuration',
+            type: resource.type,
+            icon: 'design:edit',
+            schema: this._buildResourceSchema(resourceType),
+            values,
+            submitLabel: 'Update',
+        };
+        this._splitMainViews();
+        this._onFetchDocumentation();
     }
-  }) {
-    if (items.length > 0) {
-      this._onEditResource(items[0]);
-    } else {
-      this._onCancelResourceForm();
+    _onCloseDocumentation() {
+        this.documentation = null;
     }
-  }
-
-  _onEditResource(resource) {
-    const values = { ...resource,
-      ...resource.configuration
-    };
-    delete values.configuration;
-
-    const resourceType = this._findResourceById(resource.type);
-
-    this._currentResource = {
-      _id: resource._id,
-      title: 'Resource configuration',
-      type: resource.type,
-      icon: 'design:edit',
-      schema: this._buildResourceSchema(resourceType),
-      values,
-      submitLabel: 'Update'
-    };
+    _getCurrentResourceType() {
+        return this._currentResource ? this._findResourceById(this._currentResource.type) : null;
+    }
+    _onFetchDocumentation() {
+        dispatchCustomEvent(this, 'fetch-documentation', { target: this, resourceType: this._getCurrentResourceType() });
+    }
+    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._onCancelResourceForm());
+        }
+        return Promise.resolve();
+    }
+    _onChangeResourceState(item, event) {
+        const index = this.resources.find((r) => r._id === item._id);
+        this.resources[index] = { ...this.resources[index], enabled: item.enabled };
+        dispatchCustomEvent(this, 'change', { resources: this.resources });
+    }
+    _renderForm() {
+        const values = { ...this._currentResource.values, ...this._currentResource._values };
+        return html `<gv-schema-form
+      scrollable
+      .schema="${this._currentResource.schema}"
+      .values="${values}"
+      submitLabel="${this._currentResource.submitLabel}"
+      has-header
+      .icon="${this._currentResource.icon}"
+      validate-on-render
+      .dirty="${this._currentResource.dirty || this._currentResource._values != null}"
+      ?readonly="${this.readonly}"
+      @gv-schema-form:change="${this._onChangeResourceForm}"
+      @gv-schema-form:reset="${this._onResetResourceForm}"
+      @gv-schema-form:submit="${this._onSubmitResourceForm}"
+    >
+      <div slot="title" class="form-title">${this._currentResource.title}</div>
+      <gv-button
+        slot="header-left"
+        icon="general:close"
+        outlined
+        small
+        @gv-button:click="${this._onCancelResourceForm}"
+        title="Close (esc)"
+      ></gv-button>
+      <gv-button
+        slot="header-left"
+        icon="home:book"
+        ?disabled="${this.documentation != null}"
+        outlined
+        small
+        @gv-button:click="${this._onFetchDocumentation}"
+        title="Open documentation"
+      ></gv-button>
+    </gv-schema-form>`;
+    }
+    _renderDoc() {
+        return html `<gv-documentation
+      .text="${this.documentation.content}"
+      .image="${this.documentation.image}"
+      @gv-documentation:close="${this._onCloseDocumentation}"
+    ></gv-documentation>`;
+    }
+    _renderBottom() {
+        if (this.documentation && this._currentResource) {
+            return html ` <gv-resizable-views direction="horizontal" no-overflow>
+        <div slot="top">${this._renderForm()}</div>
+        <div slot="bottom">${this._renderDoc()}</div>
+      </gv-resizable-views>`;
+        }
+        else if (this._currentResource) {
+            return this._renderForm();
+        }
+        else if (this.documentation) {
+            return this._renderDoc();
+        }
+        else if (this.readonly !== true) {
+            const resourceOpts = this.types.map((resource) => {
+                return { id: resource.id, title: resource.name, description: resource.description, image: resource.icon };
+            });
+            return html `<div class="resources-bottom-container">
+                        <gv-option class="resource__option" .options="${resourceOpts}" @gv-option:select="${this._onCreateResource}">
+                  </div>`;
+        }
+        else if (this.readonly && this.resources.length > 0) {
+            return html `<div class="resources-bottom-container empty">You can see the resource configuration by clicking on it</div>`;
+        }
+    }
+    _onSearchResource({ detail }) {
+        this._filter = detail;
+    }
+    _onClearResource() {
+        this._filter = null;
+    }
+    render() {
+        const options = {
+            selectable: true,
+            data: [
+                { field: 'name', label: 'Name' },
+                {
+                    field: 'type',
+                    width: '50px',
+                    type: 'gv-image',
+                    attributes: {
+                        src: (item) => {
+                            const resourceType = this._findResourceById(item.type);
+                            return resourceType ? resourceType.icon : null;
+                        },
+                        style: 'width:40px;height:40px;',
+                    },
+                },
+                { field: 'type', label: 'Type' },
+                {
+                    field: 'enabled',
+                    type: 'gv-switch',
+                    title: (item) => (item.enabled ? 'Click to disable' : 'Click to enable'),
+                    width: '50px',
+                    attributes: {
+                        readonly: this.readonly,
+                        'ongv-switch:input': (item, event) => this._onChangeResourceState(item, event),
+                    },
+                },
+            ],
+        };
+        if (this.readonly !== true) {
+            options.data.push({
+                type: 'gv-button',
+                width: '50px',
+                attributes: {
+                    onClick: (item) => this._removeResource(item),
+                    title: 'remove',
+                    danger: true,
+                    outlined: true,
+                    icon: 'home:trash',
+                },
+            });
+        }
+        const filteredResources = this._filter != null
+            ? this.resources.filter((resource) => {
+                return (resource.name.toLowerCase() + resource.type.toLowerCase()).includes(this._filter);
+            })
+            : this.resources;
+        return html `<div class="resources">
+      <gv-resizable-views no-overflow>
+        <div slot="top" class="box">
+          <div class="container">
+            <div class="header">
+              <div class="title">Manage global resources <span>(${this.resources.length})</span></div>
+              <gv-input
+                id="search-resource"
+                class="search-input"
+                placeholder="Filter resources (Shift + Ctrl + Space)"
+                type="search"
+                small
+                @gv-input:input="${this._onSearchResource}"
+                @gv-input:clear="${this._onClearResource}"
+              ></gv-input>
+            </div>
+            <div class="content">
+              <div class="table-container">
+                <gv-table
+                  .options="${options}"
+                  .items="${filteredResources}"
+                  emptymessage="${this._emptymessage}"
+                  @gv-table:select="${this._onSelectResource}"
+                  order="name"
+                  rowheight="50px"
+                ></gv-table>
+              </div>
+            </div>
+          </div>
+        </div>
+        <div slot="bottom">${this._renderBottom()}</div>
+      </gv-resizable-views>
+    </div>`;
+    }
+    static get styles() {
+        return [
+            empty,
+            // language=CSS
+            css `
+        :host {
+          box-sizing: border-box;
+          height: 100%;
+          width: 100%;
+          display: block;
+        }
 
-    this._splitMainViews();
+        .resources {
+          display: flex;
+          height: 100%;
+          width: 100%;
+        }
 
-    this._onFetchDocumentation();
-  }
+        gv-resizable-views {
+          height: 100%;
+          width: 100%;
+        }
 
-  _onCloseDocumentation() {
-    this.documentation = null;
-  }
+        gv-table {
+          --gv-table-rows--ov: none;
+        }
 
-  _getCurrentResourceType() {
-    return this._currentResource ? this._findResourceById(this._currentResource.type) : null;
-  }
+        .header {
+          border-bottom: 1px solid #d9d9d9;
+          display: flex;
+          min-height: 45px;
+          align-items: center;
+          margin-bottom: 0.5rem;
+          padding: 0 0.5rem;
+        }
 
-  _onFetchDocumentation() {
-    dispatchCustomEvent(this, 'fetch-documentation', {
-      target: this,
-      resourceType: this._getCurrentResourceType()
-    });
-  }
+        .header .title {
+          color: #28444f;
+          font-size: 18px;
+          display: flex;
+          align-items: flex-end;
+          flex: 1;
+        }
 
-  get dirty() {
-    const form = this.shadowRoot.querySelector('gv-schema-form');
-    return form && form.dirty;
-  }
+        .header .title span {
+          font-size: 12px;
+          margin-left: 8px;
+          opacity: 0.7;
+        }
 
-  confirm() {
-    const form = this.shadowRoot.querySelector('gv-schema-form');
+        .box {
+          position: absolute;
+          display: flex;
+          flex-direction: column;
+          width: 100%;
+          top: 0;
+          bottom: 0;
+          left: 0;
+        }
 
-    if (form) {
-      return form.confirm().then(() => this._onCancelResourceForm());
-    }
+        .container {
+          flex-grow: 1;
 
-    return Promise.resolve();
-  }
+          display: flex;
+          flex-direction: column;
 
-  _onChangeResourceState(item, event) {
-    const index = this.resources.find(r => r._id === item._id);
-    this.resources[index] = { ...this.resources[index],
-      enabled: item.enabled
-    };
-    dispatchCustomEvent(this, 'change', {
-      resources: this.resources
-    });
-  }
+          /* for Firefox */
+          min-height: 0;
+          height: 100%;
+        }
 
-  _renderForm() {
-    const values = { ...this._currentResource.values,
-      ...this._currentResource._values
-    };
-    return html`<gv-schema-form scrollable .schema="${this._currentResource.schema}" .values="${values}" submitLabel="${this._currentResource.submitLabel}" has-header .icon="${this._currentResource.icon}" validate-on-render .dirty="${this._currentResource.dirty || this._currentResource._values != null}" ?readonly="${this.readonly}" @gv-schema-form:change="${this._onChangeResourceForm}" @gv-schema-form:reset="${this._onResetResourceForm}" @gv-schema-form:submit="${this._onSubmitResourceForm}"> <div slot="title" class="form-title">${this._currentResource.title}</div> <gv-button slot="header-left" icon="general:close" outlined small @gv-button:click="${this._onCancelResourceForm}" title="Close (esc)"></gv-button> <gv-button slot="header-left" icon="home:book" ?disabled="${this.documentation != null}" outlined small @gv-button:click="${this._onFetchDocumentation}" title="Open documentation"></gv-button> </gv-schema-form>`;
-  }
+        .content {
+          background: white;
+          flex-grow: 1;
 
-  _renderDoc() {
-    return html`<gv-documentation .text="${this.documentation.content}" .image="${this.documentation.image}" @gv-documentation:close="${this._onCloseDocumentation}"></gv-documentation>`;
-  }
+          overflow: auto;
 
-  _renderBottom() {
-    if (this.documentation && this._currentResource) {
-      return html` <gv-resizable-views direction="horizontal" no-overflow> <div slot="top">${this._renderForm()}</div> <div slot="bottom">${this._renderDoc()}</div> </gv-resizable-views>`;
-    } else if (this._currentResource) {
-      return this._renderForm();
-    } else if (this.documentation) {
-      return this._renderDoc();
-    } else if (this.readonly !== true) {
-      const resourceOpts = this.types.map(resource => {
-        return {
-          id: resource.id,
-          title: resource.name,
-          description: resource.description,
-          image: resource.icon
-        };
-      });
-      return html`<div class="resources-bottom-container"> <gv-option class="resource__option" .options="${resourceOpts}" @gv-option:select="${this._onCreateResource}"> </gv-option></div>`;
-    } else if (this.readonly && this.resources.length > 0) {
-      return html`<div class="resources-bottom-container empty">You can see the resource configuration by clicking on it</div>`;
-    }
-  }
+          /* for Firefox */
+          min-height: 0;
+          padding: 0.5rem;
 
-  _onSearchResource({
-    detail
-  }) {
-    this._filter = detail;
-  }
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+        }
 
-  _onClearResource() {
-    this._filter = null;
-  }
+        .form-title {
+          text-transform: uppercase;
+          letter-spacing: 0.2rem;
+        }
 
-  render() {
-    const options = {
-      selectable: true,
-      data: [{
-        field: 'name',
-        label: 'Name'
-      }, {
-        field: 'type',
-        width: '50px',
-        type: 'gv-image',
-        attributes: {
-          src: item => {
-            const resourceType = this._findResourceById(item.type);
+        .resources-bottom-container {
+          display: flex;
+          justify-content: center;
+          align-items: center;
+          height: 100%;
+        }
 
-            return resourceType ? resourceType.icon : null;
-          },
-          style: 'width:40px;height:40px;'
+        .table-container {
+          max-width: 1200px;
+          display: flex;
+          flex-direction: column;
+          width: 100%;
         }
-      }, {
-        field: 'type',
-        label: 'Type'
-      }, {
-        field: 'enabled',
-        type: 'gv-switch',
-        title: item => item.enabled ? 'Click to disable' : 'Click to enable',
-        width: '50px',
-        attributes: {
-          readonly: this.readonly,
-          'ongv-switch:input': (item, event) => this._onChangeResourceState(item, event)
+
+        .search-input {
+          width: 300px;
         }
-      }]
-    };
 
-    if (this.readonly !== true) {
-      options.data.push({
-        type: 'gv-button',
-        width: '50px',
-        attributes: {
-          onClick: item => this._removeResource(item),
-          title: 'remove',
-          danger: true,
-          outlined: true,
-          icon: 'home:trash'
+        .resource__option {
+          --gv-option-button--maw: 175px;
         }
-      });
+      `,
+        ];
     }
-
-    const filteredResources = this._filter != null ? this.resources.filter(resource => {
-      return (resource.name.toLowerCase() + resource.type.toLowerCase()).includes(this._filter);
-    }) : this.resources;
-    return html`<div class="resources"> <gv-resizable-views no-overflow> <div slot="top" class="box"> <div class="container"> <div class="header"> <div class="title">Manage global resources <span>(${this.resources.length})</span></div> <gv-input id="search-resource" class="search-input" placeholder="Filter resources (Shift + Ctrl + Space)" type="search" small @gv-input:input="${this._onSearchResource}" @gv-input:clear="${this._onClearResource}"></gv-input> </div> <div class="content"> <div class="table-container"> <gv-table .options="${options}" .items="${filteredResources}" emptymessage="${this._emptymessage}" @gv-table:select="${this._onSelectResource}" order="name" rowheight="50px"></gv-table> </div> </div> </div> </div> <div slot="bottom">${this._renderBottom()}</div> </gv-resizable-views> </div>`;
-  }
-
-  static get styles() {
-    return [empty, // language=CSS
-    css`:host{box-sizing:border-box;height:100%;width:100%;display:block}.resources{display:flex;height:100%;width:100%}gv-resizable-views{height:100%;width:100%}gv-table{--gv-table-rows--ov:none}.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}.form-title{text-transform:uppercase;letter-spacing:.2rem}.resources-bottom-container{display:flex;justify-content:center;align-items:center;height:100%}.table-container{max-width:1200px;display:flex;flex-direction:column;width:100%}.search-input{width:300px}.resource__option{--gv-option-button--maw:175px}`];
-  }
-
 }
 window.customElements.define('gv-resources', GvResources);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["./node_modules/@gravitee/ui-components/organisms/gv-resources.js"],"names":["css","html","LitElement","dispatchCustomEvent","uuid","KeyboardElement","KEYS","empty","GvResources","properties","resources","type","Array","_resources","attribute","types","documentation","Object","_currentResource","_currentResourceLoading","Boolean","_filter","String","readonly","reflect","constructor","_emptymessage","onKeyboard","isPressed","Esc","_onCancelResourceForm","Shift","Ctrl","Space","search","shadowRoot","querySelector","focus","firstUpdated","views","updateComplete","then","_maximizeTopView","_generateId","list","map","e","_id","_getResizableViews","resize","_maximizeBottomView","maximizeBottom","_splitMainViews","split","_removeResource","item","filter","resource","_buildResourceSchema","resourceType","defaultSchema","name","title","required","schema","JSON","parse","_onCreateResource","detail","defaultResourceType","find","id","icon","values","submitLabel","dirty","_onFetchDocumentation","setTimeout","_onSubmitResourceForm","_values","configuration","index","findIndex","r","enabled","push","_onChangeResourceForm","_onResetResourceForm","_findResourceById","_onSelectResource","items","length","_onEditResource","_onCloseDocumentation","_getCurrentResourceType","target","form","confirm","Promise","resolve","_onChangeResourceState","event","_renderForm","_renderDoc","content","image","_renderBottom","resourceOpts","description","_onSearchResource","_onClearResource","render","options","selectable","data","field","label","width","attributes","src","style","onClick","danger","outlined","filteredResources","toLowerCase","includes","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 './gv-documentation';\nimport '../molecules/gv-table';\nimport '../atoms/gv-button';\nimport '../molecules/gv-option';\nimport '../atoms/gv-switch';\nimport '../atoms/gv-icon';\nimport { dispatchCustomEvent } from '../lib/events';\nimport { uuid } from '../lib/utils';\nimport { KeyboardElement, KEYS } from '../mixins/keyboard-element';\nimport { empty } from '../styles/empty';\n\nexport class GvResources extends KeyboardElement(LitElement) {\n  static get properties() {\n    return {\n      resources: { type: Array },\n      _resources: { type: Array, attribute: false },\n      types: { type: Array },\n      documentation: { type: Object },\n      _currentResource: { type: Object, attribute: false },\n      _currentResourceLoading: { type: Boolean, attribute: false },\n      _filter: { type: String },\n      readonly: { type: Boolean, reflect: true },\n    };\n  }\n\n  constructor() {\n    super();\n    this.resources = [];\n    this.types = [];\n    this._currentResource = null;\n    this._emptymessage = 'No resource';\n  }\n\n  onKeyboard() {\n    if (this.isPressed(KEYS.Esc)) {\n      this._onCancelResourceForm();\n    }\n    if (this.isPressed(KEYS.Shift, KEYS.Ctrl, KEYS.Space)) {\n      const search = this.shadowRoot.querySelector('#search-resource');\n      if (search) {\n        search.focus();\n      }\n    }\n  }\n\n  firstUpdated() {\n    const views = this.shadowRoot.querySelector('gv-resizable-views');\n    if (views != null) {\n      views.updateComplete.then(() => {\n        this._maximizeTopView();\n      });\n    }\n  }\n\n  set resources(resources) {\n    this._resources = this._generateId(resources);\n  }\n\n  get resources() {\n    return this._resources;\n  }\n\n  _generateId(list) {\n    if (list) {\n      return list.map((e) => {\n        if (e._id == null) {\n          e._id = uuid();\n        }\n        return e;\n      });\n    }\n    return list;\n  }\n\n  _getResizableViews() {\n    return this.shadowRoot.querySelector('gv-resizable-views');\n  }\n\n  _maximizeTopView() {\n    this._getResizableViews().resize(60, 40);\n  }\n\n  _maximizeBottomView() {\n    this._getResizableViews().maximizeBottom();\n  }\n\n  _splitMainViews() {\n    this._getResizableViews().split();\n  }\n\n  _onCancelResourceForm() {\n    this._currentResource = null;\n    this.documentation = null;\n    this._maximizeTopView();\n  }\n\n  _removeResource(item) {\n    this.resources = this.resources.filter((resource) => resource._id !== item._id);\n    this._onCancelResourceForm();\n    dispatchCustomEvent(this, 'change', { resources: this.resources });\n  }\n\n  _buildResourceSchema(resourceType) {\n    const defaultSchema = {\n      properties: {\n        name: {\n          type: 'string',\n          title: 'Resource name',\n        },\n      },\n      required: ['name'],\n    };\n\n    const schema = typeof resourceType.schema === 'string' ? JSON.parse(resourceType.schema) : resourceType.schema;\n\n    return {\n      properties: { ...defaultSchema.properties, ...schema.properties },\n      required: [...defaultSchema.required, ...schema.required],\n    };\n  }\n\n  _onCreateResource({ detail }) {\n    this._currentResourceLoading = true;\n    const defaultResourceType = this.types.find((type) => type.id === detail.id);\n    const schema = this._buildResourceSchema(defaultResourceType);\n    this._currentResource = {\n      type: defaultResourceType.id,\n      title: 'Create resource',\n      icon: 'code:plus',\n      schema,\n      values: {},\n      submitLabel: 'Add',\n      dirty: true,\n    };\n    this._maximizeBottomView();\n    this._onFetchDocumentation();\n    setTimeout(() => (this._currentResourceLoading = false), 600);\n  }\n\n  _onSubmitResourceForm({ detail }) {\n    delete this._currentResource._values;\n    const { type } = this._currentResource;\n    const { _id, name, ...configuration } = detail.values;\n\n    const resource = {\n      _id,\n      type,\n      name,\n      configuration,\n    };\n\n    if (detail.values._id != null) {\n      const index = this.resources.findIndex((r) => r._id === resource._id);\n      this.resources[index] = { ...this.resources[index], ...resource };\n    } else {\n      if (this.resources == null) {\n        this.resources = [];\n      }\n      resource._id = uuid();\n      resource.enabled = true;\n      this.resources.push(resource);\n    }\n    this._onCancelResourceForm();\n    dispatchCustomEvent(this, 'change', { resources: this.resources });\n  }\n\n  _onChangeResourceForm({ detail }) {\n    this._currentResource._values = detail.values;\n  }\n\n  _onResetResourceForm() {\n    delete this._currentResource._values;\n  }\n\n  _findResourceById(id) {\n    return this.types.find((resource) => resource.id === id);\n  }\n\n  // For readonly mode\n  _onSelectResource({ detail: { items } }) {\n    if (items.length > 0) {\n      this._onEditResource(items[0]);\n    } else {\n      this._onCancelResourceForm();\n    }\n  }\n\n  _onEditResource(resource) {\n    const values = { ...resource, ...resource.configuration };\n    delete values.configuration;\n    const resourceType = this._findResourceById(resource.type);\n    this._currentResource = {\n      _id: resource._id,\n      title: 'Resource configuration',\n      type: resource.type,\n      icon: 'design:edit',\n      schema: this._buildResourceSchema(resourceType),\n      values,\n      submitLabel: 'Update',\n    };\n    this._splitMainViews();\n    this._onFetchDocumentation();\n  }\n\n  _onCloseDocumentation() {\n    this.documentation = null;\n  }\n\n  _getCurrentResourceType() {\n    return this._currentResource ? this._findResourceById(this._currentResource.type) : null;\n  }\n\n  _onFetchDocumentation() {\n    dispatchCustomEvent(this, 'fetch-documentation', { target: this, resourceType: this._getCurrentResourceType() });\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._onCancelResourceForm());\n    }\n    return Promise.resolve();\n  }\n\n  _onChangeResourceState(item, event) {\n    const index = this.resources.find((r) => r._id === item._id);\n    this.resources[index] = { ...this.resources[index], enabled: item.enabled };\n    dispatchCustomEvent(this, 'change', { resources: this.resources });\n  }\n\n  _renderForm() {\n    const values = { ...this._currentResource.values, ...this._currentResource._values };\n    return html`<gv-schema-form\n      scrollable\n      .schema=\"${this._currentResource.schema}\"\n      .values=\"${values}\"\n      submitLabel=\"${this._currentResource.submitLabel}\"\n      has-header\n      .icon=\"${this._currentResource.icon}\"\n      validate-on-render\n      .dirty=\"${this._currentResource.dirty || this._currentResource._values != null}\"\n      ?readonly=\"${this.readonly}\"\n      @gv-schema-form:change=\"${this._onChangeResourceForm}\"\n      @gv-schema-form:reset=\"${this._onResetResourceForm}\"\n      @gv-schema-form:submit=\"${this._onSubmitResourceForm}\"\n    >\n      <div slot=\"title\" class=\"form-title\">${this._currentResource.title}</div>\n      <gv-button\n        slot=\"header-left\"\n        icon=\"general:close\"\n        outlined\n        small\n        @gv-button:click=\"${this._onCancelResourceForm}\"\n        title=\"Close (esc)\"\n      ></gv-button>\n      <gv-button\n        slot=\"header-left\"\n        icon=\"home:book\"\n        ?disabled=\"${this.documentation != null}\"\n        outlined\n        small\n        @gv-button:click=\"${this._onFetchDocumentation}\"\n        title=\"Open documentation\"\n      ></gv-button>\n    </gv-schema-form>`;\n  }\n\n  _renderDoc() {\n    return html`<gv-documentation\n      .text=\"${this.documentation.content}\"\n      .image=\"${this.documentation.image}\"\n      @gv-documentation:close=\"${this._onCloseDocumentation}\"\n    ></gv-documentation>`;\n  }\n\n  _renderBottom() {\n    if (this.documentation && this._currentResource) {\n      return html` <gv-resizable-views direction=\"horizontal\" no-overflow>\n        <div slot=\"top\">${this._renderForm()}</div>\n        <div slot=\"bottom\">${this._renderDoc()}</div>\n      </gv-resizable-views>`;\n    } else if (this._currentResource) {\n      return this._renderForm();\n    } else if (this.documentation) {\n      return this._renderDoc();\n    } else if (this.readonly !== true) {\n      const resourceOpts = this.types.map((resource) => {\n        return { id: resource.id, title: resource.name, description: resource.description, image: resource.icon };\n      });\n\n      return html`<div class=\"resources-bottom-container\">\n                        <gv-option class=\"resource__option\" .options=\"${resourceOpts}\" @gv-option:select=\"${this._onCreateResource}\">\n                  </div>`;\n    } else if (this.readonly && this.resources.length > 0) {\n      return html`<div class=\"resources-bottom-container empty\">You can see the resource configuration by clicking on it</div>`;\n    }\n  }\n\n  _onSearchResource({ detail }) {\n    this._filter = detail;\n  }\n\n  _onClearResource() {\n    this._filter = null;\n  }\n\n  render() {\n    const options = {\n      selectable: true,\n      data: [\n        { field: 'name', label: 'Name' },\n        {\n          field: 'type',\n          width: '50px',\n          type: 'gv-image',\n          attributes: {\n            src: (item) => {\n              const resourceType = this._findResourceById(item.type);\n              return resourceType ? resourceType.icon : null;\n            },\n            style: 'width:40px;height:40px;',\n          },\n        },\n        { field: 'type', label: 'Type' },\n        {\n          field: 'enabled',\n          type: 'gv-switch',\n          title: (item) => (item.enabled ? 'Click to disable' : 'Click to enable'),\n          width: '50px',\n          attributes: {\n            readonly: this.readonly,\n            'ongv-switch:input': (item, event) => this._onChangeResourceState(item, event),\n          },\n        },\n      ],\n    };\n\n    if (this.readonly !== true) {\n      options.data.push({\n        type: 'gv-button',\n        width: '50px',\n        attributes: {\n          onClick: (item) => this._removeResource(item),\n          title: 'remove',\n          danger: true,\n          outlined: true,\n          icon: 'home:trash',\n        },\n      });\n    }\n\n    const filteredResources =\n      this._filter != null\n        ? this.resources.filter((resource) => {\n            return (resource.name.toLowerCase() + resource.type.toLowerCase()).includes(this._filter);\n          })\n        : this.resources;\n\n    return html`<div class=\"resources\">\n      <gv-resizable-views no-overflow>\n        <div slot=\"top\" class=\"box\">\n          <div class=\"container\">\n            <div class=\"header\">\n              <div class=\"title\">Manage global resources <span>(${this.resources.length})</span></div>\n              <gv-input\n                id=\"search-resource\"\n                class=\"search-input\"\n                placeholder=\"Filter resources (Shift + Ctrl + Space)\"\n                type=\"search\"\n                small\n                @gv-input:input=\"${this._onSearchResource}\"\n                @gv-input:clear=\"${this._onClearResource}\"\n              ></gv-input>\n            </div>\n            <div class=\"content\">\n              <div class=\"table-container\">\n                <gv-table\n                  .options=\"${options}\"\n                  .items=\"${filteredResources}\"\n                  emptymessage=\"${this._emptymessage}\"\n                  @gv-table:select=\"${this._onSelectResource}\"\n                  order=\"name\"\n                  rowheight=\"50px\"\n                ></gv-table>\n              </div>\n            </div>\n          </div>\n        </div>\n        <div slot=\"bottom\">${this._renderBottom()}</div>\n      </gv-resizable-views>\n    </div>`;\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        .resources {\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-table {\n          --gv-table-rows--ov: none;\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        .form-title {\n          text-transform: uppercase;\n          letter-spacing: 0.2rem;\n        }\n\n        .resources-bottom-container {\n          display: flex;\n          justify-content: center;\n          align-items: center;\n          height: 100%;\n        }\n\n        .table-container {\n          max-width: 1200px;\n          display: flex;\n          flex-direction: column;\n          width: 100%;\n        }\n\n        .search-input {\n          width: 300px;\n        }\n\n        .resource__option {\n          --gv-option-button--maw: 175px;\n        }\n      `,\n    ];\n  }\n}\n\nwindow.customElements.define('gv-resources', GvResources);\n"]}
+//# sourceMappingURL=gv-resources.js.map