@gravitee/ui-components 3.27.0 → 3.27.1-pagination-34a0cc9

package/src/policy-studio/{gv-policy-studio.js → gv-policy-studio/gv-policy-studio.js}

@@ -1,3 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 /*
  * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
  *
@@ -14,25 +34,25 @@
  * limitations under the License.
  */
 import { css, html, LitElement } from 'lit';
-import { methods } from '../lib/studio';
-import { dispatchCustomEvent } from '../lib/events';
-import { i18n } from '../lib/i18n';
-import '../atoms/gv-button';
-import '../atoms/gv-icon';
-import '../molecules/gv-option';
-import '../organisms/gv-documentation';
-import '../organisms/gv-resizable-views';
-import '../organisms/gv-schema-form';
-import '../organisms/gv-http-client';
-import '../organisms/gv-tabs';
-import '../molecules/gv-row';
-import './gv-flow';
-import './gv-flow-step';
-import './gv-policy-studio-menu';
-import { empty } from '../styles/empty';
+import { methods } from '../../lib/studio';
+import { dispatchCustomEvent } from '../../lib/events';
+import { i18n } from '../../lib/i18n';
+import '../../atoms/gv-button';
+import '../../atoms/gv-icon';
+import '../../molecules/gv-option';
+import '../../organisms/gv-documentation';
+import '../../organisms/gv-resizable-views';
+import '../../organisms/gv-schema-form';
+import '../../organisms/gv-http-client';
+import '../../organisms/gv-tabs';
+import '../../molecules/gv-row';
+import '../gv-flow';
+import '../gv-flow-step';
+import '../gv-policy-studio-menu';
+import { empty } from '../../styles/empty';
 import { cache } from 'lit/directives/cache';
-import { deepClone, deepEqual } from '../lib/utils';
-import { KeyboardElement, KEYS } from '../mixins/keyboard-element';
+import { deepClone, deepEqual } from '../../lib/utils';
+import { KeyboardElement, KEYS } from '../../mixins/keyboard-element';
 const FLOW_STEP_FORM_ID = 'flow-step-form';
 /**
  *  Studio Policy component
@@ -83,7 +103,6 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             documentation: { type: Object },
             flowSchema: { type: Object, attribute: 'flow-schema' },
             configurationSchema: { type: Object, attribute: 'configuration-schema' },
-            _configurationSchema: { type: Object, attribute: false },
             configurationInformation: { type: String, attribute: 'configuration-information' },
             isDirty: { type: Boolean, attribute: 'dirty', reflect: true },
             _dragPolicy: { type: Object, attribute: false },
@@ -99,7 +118,6 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             _flowFilter: { type: Array, attribute: false },
             _currentAskConfirmation: { type: Boolean, attribute: false },
             hasProperties: { type: Boolean, attribute: 'has-properties' },
-            _hasProperties: { type: Boolean, attribute: false },
             hasResources: { type: Boolean, attribute: 'has-resources' },
             hasPolicyFilter: { type: Boolean, attribute: 'has-policy-filter' },
             flowsTitle: { type: String, attribute: 'flows-title' },
@@ -108,7 +126,6 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             readonly: { type: Boolean },
             readonlyPlans: { type: Boolean, attribute: 'readonly-plans' },
             canDebug: { type: Boolean, attribute: 'can-debug' },
-            _canDebug: { type: Boolean, attribute: false },
             debugResponse: { type: Object, attribute: 'debug-response' },
             hasConditionalSteps: { type: Boolean, attribute: 'has-conditional-steps' },
         };
@@ -353,30 +370,33 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         this._policyFilter = [];
         this._flowFilter = [];
     }
-    set hasProperties(value) {
-        if (value) {
-            import('../organisms/gv-properties').then(() => {
-                this._tabs = [...this._tabs, { id: 'properties', title: 'Properties', icon: 'general:settings#1' }];
-                this.requestUpdate();
-            });
-        }
-        this._hasProperties = value;
-    }
-    get hasProperties() {
-        return this._hasProperties;
-    }
-    set hasResources(value) {
-        if (value) {
-            import('../organisms/gv-resources').then(() => {
-                this._tabs = [...this._tabs, { id: 'resources', title: 'Resources', icon: 'general:settings#5' }];
+    willUpdate(changedProperties) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (changedProperties.has('configurationSchema') && this.configurationSchema) {
+                this._tabs.splice(1, 0, { id: 'settings', title: 'Configuration', icon: 'general:settings#2' });
+            }
+            if (changedProperties.has('hasPolicyFilter') && this.hasPolicyFilter === true) {
+                this._policyFilterOptions = [
+                    { id: 'onRequest', title: 'Request', icon: 'navigation:arrow-from-left' },
+                    { id: 'onResponse', title: 'Response', icon: 'navigation:arrow-from-right' },
+                ];
+            }
+            if (changedProperties.has('canDebug') && this.canDebug === true) {
+                this._tabs = [...this._tabs, { id: 'debug', title: 'Try it', icon: 'content:send' }];
+            }
+            const tabsImport = [];
+            if (changedProperties.has('hasProperties') && this.hasProperties === true) {
+                tabsImport.push(import('../../organisms/gv-properties').then(() => ({ id: 'properties', title: 'Properties', icon: 'general:settings#1' })));
+            }
+            if (changedProperties.has('hasResources') && this.hasProperties === true) {
+                tabsImport.push(import('../../organisms/gv-resources').then(() => ({ id: 'resources', title: 'Resources', icon: 'general:settings#5' })));
+            }
+            if (tabsImport.length > 0) {
+                const [...tabs] = yield Promise.all(tabsImport);
+                this._tabs = [...this._tabs, ...tabs];
                 this.requestUpdate();
-            });
-        }
-    }
-    set canDebug(value) {
-        if (value) {
-            this._tabs = [...this._tabs, { id: 'debug', title: 'Try it', icon: 'content:send' }];
-        }
+            }
+        });
     }
     get _flowFilterOptions() {
         if (this.definedPlans.length > 0) {
@@ -386,22 +406,8 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             ];
         }
     }
-    set hasPolicyFilter(value) {
-        if (value) {
-            this._policyFilterOptions = [
-                { id: 'onRequest', title: 'Request', icon: 'navigation:arrow-from-left' },
-                { id: 'onResponse', title: 'Response', icon: 'navigation:arrow-from-right' },
-            ];
-        }
-    }
-    set configurationSchema(value) {
-        if (value) {
-            this._tabs.splice(1, 0, { id: 'settings', title: 'Configuration', icon: 'general:settings#2' });
-        }
-        this._configurationSchema = value;
-    }
-    get configurationSchema() {
-        return this._configurationSchema;
+    get keyboardTarget() {
+        return window;
     }
     onKeyboard() {
         if (this._currentAskConfirmation == null) {
@@ -437,9 +443,9 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             const plans = definition.plans == null
                 ? []
                 : definition.plans.map((plan) => {
-                    return { ...plan, flows: this._generatePlanFlowsId(plan) };
+                    return Object.assign(Object.assign({}, plan), { flows: this._generatePlanFlowsId(plan) });
                 });
-            this._initialDefinition = { ...definition, flows, resources, plans };
+            this._initialDefinition = Object.assign(Object.assign({}, definition), { flows, resources, plans });
             this._definition = deepClone(this._initialDefinition);
             this.isDirty = false;
             this._selectFirstFlow();
@@ -491,90 +497,92 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
     _onDragEndPolicy() {
         this.shadowRoot.querySelectorAll('gv-flow').forEach((e) => e.onDragEnd());
     }
-    async _onDropPolicy({ detail }) {
-        try {
-            await this._askToValidateForms();
-            const policy = detail.policy;
-            const targetFlow = this._findFlowById(detail.flowId);
-            let name = policy.name;
-            let description = '';
-            let condition = '';
-            let configuration = {};
-            let _id;
-            let _new = false;
-            if (detail.flowStep) {
-                _id = detail.flowStep._id;
-                name = detail.flowStep.name;
-                description = detail.flowStep.description || '';
-                condition = detail.flowStep.condition || '';
-                configuration = detail.flowStep.configuration;
-            }
-            else {
-                _id = this._generateFlowStepId(targetFlow._id, detail.flowKey, detail.position);
-                _new = true;
-            }
-            const flowStep = { _id, _new, name, policy: policy.id, description, condition, enabled: true, configuration };
-            const sourceFlow = detail.sourceFlowId != null ? this._findFlowById(detail.sourceFlowId) : targetFlow;
-            if (detail.sourcePosition != null) {
-                if (detail.sourceFlowKey && detail.sourceFlowKey !== detail.flowKey) {
-                    sourceFlow[detail.sourceFlowKey].splice(detail.sourcePosition, 1);
-                    targetFlow[detail.flowKey].splice(detail.position, 0, flowStep);
-                    if (this._currentFlowStep != null && this._currentFlowStep.step._id === _id) {
-                        this._currentFlowStep.group = detail.flowKey;
-                        // Special case for update schema after change request to response or inverse
-                        const schema = this.buildSchema(this._currentFlowStep.policy);
-                        await this._setCurrentFlowStep(this._currentFlowStep, schema, true);
-                        this._getFlowElement(targetFlow._id).requestUpdate();
-                    }
+    _onDropPolicy({ detail }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._askToValidateForms();
+                const policy = detail.policy;
+                const targetFlow = this._findFlowById(detail.flowId);
+                let name = policy.name;
+                let description = '';
+                let condition = '';
+                let configuration = {};
+                let _id;
+                let _new = false;
+                if (detail.flowStep) {
+                    _id = detail.flowStep._id;
+                    name = detail.flowStep.name;
+                    description = detail.flowStep.description || '';
+                    condition = detail.flowStep.condition || '';
+                    configuration = detail.flowStep.configuration;
                 }
                 else {
-                    if (detail.position > detail.sourcePosition) {
+                    _id = this._generateFlowStepId(targetFlow._id, detail.flowKey, detail.position);
+                    _new = true;
+                }
+                const flowStep = { _id, _new, name, policy: policy.id, description, condition, enabled: true, configuration };
+                const sourceFlow = detail.sourceFlowId != null ? this._findFlowById(detail.sourceFlowId) : targetFlow;
+                if (detail.sourcePosition != null) {
+                    if (detail.sourceFlowKey && detail.sourceFlowKey !== detail.flowKey) {
+                        sourceFlow[detail.sourceFlowKey].splice(detail.sourcePosition, 1);
                         targetFlow[detail.flowKey].splice(detail.position, 0, flowStep);
-                        sourceFlow[detail.flowKey].splice(detail.sourcePosition, 1);
+                        if (this._currentFlowStep != null && this._currentFlowStep.step._id === _id) {
+                            this._currentFlowStep.group = detail.flowKey;
+                            // Special case for update schema after change request to response or inverse
+                            const schema = this.buildSchema(this._currentFlowStep.policy);
+                            yield this._setCurrentFlowStep(this._currentFlowStep, schema, true);
+                            this._getFlowElement(targetFlow._id).requestUpdate();
+                        }
                     }
                     else {
-                        sourceFlow[detail.flowKey].splice(detail.sourcePosition, 1);
-                        targetFlow[detail.flowKey].splice(detail.position, 0, flowStep);
+                        if (detail.position > detail.sourcePosition) {
+                            targetFlow[detail.flowKey].splice(detail.position, 0, flowStep);
+                            sourceFlow[detail.flowKey].splice(detail.sourcePosition, 1);
+                        }
+                        else {
+                            sourceFlow[detail.flowKey].splice(detail.sourcePosition, 1);
+                            targetFlow[detail.flowKey].splice(detail.position, 0, flowStep);
+                        }
                     }
-                }
-                // Force Refresh source flow element when move to other flow
-                if (targetFlow._id !== sourceFlow._id) {
-                    this._getFlowElement(targetFlow._id).requestUpdate();
-                }
-            }
-            else {
-                targetFlow[detail.flowKey].splice(detail.position, 0, flowStep);
-                const currentFlowForm = this._getFlowStepForm();
-                if (currentFlowForm == null || currentFlowForm.dirty !== true) {
-                    let step = targetFlow[detail.flowKey][detail.position];
-                    if (step == null) {
-                        // When confirm lose change after drop policy
-                        step = targetFlow[detail.flowKey][detail.position - 1];
+                    // Force Refresh source flow element when move to other flow
+                    if (targetFlow._id !== sourceFlow._id) {
+                        this._getFlowElement(targetFlow._id).requestUpdate();
                     }
-                    if (detail.cancelEdit !== true) {
-                        setTimeout(async () => {
-                            await this._editFlowStep({ step, policy, flow: targetFlow, group: detail.flowKey });
-                            this.updateComplete.then(() => {
-                                const flowElement = this._getFlowElement(targetFlow._id);
-                                flowElement.selectedStepId = step._id;
-                                flowElement.requestUpdate();
-                            });
-                        });
+                }
+                else {
+                    targetFlow[detail.flowKey].splice(detail.position, 0, flowStep);
+                    const currentFlowForm = this._getFlowStepForm();
+                    if (currentFlowForm == null || currentFlowForm.dirty !== true) {
+                        let step = targetFlow[detail.flowKey][detail.position];
+                        if (step == null) {
+                            // When confirm lose change after drop policy
+                            step = targetFlow[detail.flowKey][detail.position - 1];
+                        }
+                        if (detail.cancelEdit !== true) {
+                            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                                yield this._editFlowStep({ step, policy, flow: targetFlow, group: detail.flowKey });
+                                this.updateComplete.then(() => {
+                                    const flowElement = this._getFlowElement(targetFlow._id);
+                                    flowElement.selectedStepId = step._id;
+                                    flowElement.requestUpdate();
+                                });
+                            }));
+                        }
                     }
                 }
+                targetFlow._dirty = true;
+                sourceFlow._dirty = true;
+                this.isDirty = true;
+                this.shadowRoot.querySelectorAll('gv-flow').forEach((gvFlow) => gvFlow.removeCandidate());
+                setTimeout(() => {
+                    this._dragPolicy = null;
+                    this._dropPolicy = null;
+                }, 0);
             }
-            targetFlow._dirty = true;
-            sourceFlow._dirty = true;
-            this.isDirty = true;
-            this.shadowRoot.querySelectorAll('gv-flow').forEach((gvFlow) => gvFlow.removeCandidate());
-            setTimeout(() => {
-                this._dragPolicy = null;
-                this._dropPolicy = null;
-            }, 0);
-        }
-        catch (e) {
-            this._currentAskConfirmation = null;
-        }
+            catch (e) {
+                this._currentAskConfirmation = null;
+            }
+        });
     }
     _onDeletePolicy({ detail }) {
         const targetFlow = this._findFlowById(detail.flowId);
@@ -606,35 +614,39 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         };
         if (schema) {
             const jsonSchema = typeof schema === 'string' ? JSON.parse(schema) : schema;
-            const properties = { commonDescription, ...(this.hasConditionalSteps ? { commonCondition } : {}), ...jsonSchema.properties };
-            return { ...jsonSchema, properties };
+            const properties = Object.assign(Object.assign({ commonDescription }, (this.hasConditionalSteps ? { commonCondition } : {})), jsonSchema.properties);
+            return Object.assign(Object.assign({}, jsonSchema), { properties });
         }
-        return { properties: { commonDescription, ...(this.hasConditionalSteps ? { commonCondition } : {}) } };
+        return { properties: Object.assign({ commonDescription }, (this.hasConditionalSteps ? { commonCondition } : {})) };
     }
-    async _editFlowStep({ step, flow, policy, group }) {
-        if (step) {
-            this._currentPolicyId = policy.id;
-            const currentFlowStep = { flow, step, policy, group };
-            const schema = this.buildSchema(policy);
-            try {
-                await this._setCurrentFlowStep(currentFlowStep, schema);
-                this._updateSelectedFlows([flow._id]);
-                this._splitMainViews();
-                if (localStorage.getItem('gv-policy-studio:keep-documentation-close') == null) {
-                    this._onOpenDocumentation();
+    _editFlowStep({ step, flow, policy, group }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (step) {
+                this._currentPolicyId = policy.id;
+                const currentFlowStep = { flow, step, policy, group };
+                const schema = this.buildSchema(policy);
+                try {
+                    yield this._setCurrentFlowStep(currentFlowStep, schema);
+                    this._updateSelectedFlows([flow._id]);
+                    this._splitMainViews();
+                    if (localStorage.getItem('gv-policy-studio:keep-documentation-close') == null) {
+                        this._onOpenDocumentation();
+                    }
+                }
+                catch (e) {
+                    this._currentAskConfirmation = null;
                 }
             }
-            catch (e) {
-                this._currentAskConfirmation = null;
+            else {
+                yield this._closeFlowStepForm();
+                this._maximizeTopView();
             }
-        }
-        else {
-            await this._closeFlowStepForm();
-            this._maximizeTopView();
-        }
+        });
     }
-    async _onEditFlowStep({ detail: { step, flow, policy, group } }) {
-        return this._editFlowStep({ step, flow, policy, group });
+    _onEditFlowStep({ detail: { step, flow, policy, group } }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._editFlowStep({ step, flow, policy, group });
+        });
     }
     _getResizableViews() {
         return this.shadowRoot.querySelector('gv-resizable-views');
@@ -657,74 +669,82 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         targetFlow._dirty = true;
         this.isDirty = true;
     }
-    async _onCloseFlowStepForm() {
-        try {
-            await this._closeFlowStepForm();
-        }
-        catch (err) {
-            this._currentAskConfirmation = null;
-        }
+    _onCloseFlowStepForm() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._closeFlowStepForm();
+            }
+            catch (err) {
+                this._currentAskConfirmation = null;
+            }
+        });
     }
-    async _closeFlowStepForm(force = false) {
-        await this._setCurrentFlowStep(null, null, force);
+    _closeFlowStepForm(force = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._setCurrentFlowStep(null, null, force);
+        });
     }
-    async _askToValidateForms() {
-        if (this._currentAskConfirmation == null) {
-            this._currentAskConfirmation = true;
-            return Promise.all(this._submitOrConfirmForms()).then((forms) => {
-                if (forms.filter((r) => r != null).length > 0) {
-                    this._definition = this._buildDefinitionToSave();
-                    this.getChildren().forEach((e) => e.requestUpdate());
-                    // Refresh if lose changes lost current step selection
-                    return this._checkCurrentFlowStep().then(() => {
+    _askToValidateForms() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._currentAskConfirmation == null) {
+                this._currentAskConfirmation = true;
+                return Promise.all(this._submitOrConfirmForms()).then((forms) => {
+                    if (forms.filter((r) => r != null).length > 0) {
+                        this._definition = this._buildDefinitionToSave();
                         this.getChildren().forEach((e) => e.requestUpdate());
-                        return this.updateComplete.then(() => {
-                            this._currentAskConfirmation = null;
-                            return forms;
+                        // Refresh if lose changes lost current step selection
+                        return this._checkCurrentFlowStep().then(() => {
+                            this.getChildren().forEach((e) => e.requestUpdate());
+                            return this.updateComplete.then(() => {
+                                this._currentAskConfirmation = null;
+                                return forms;
+                            });
                         });
-                    });
-                }
-                else {
-                    this._currentAskConfirmation = null;
-                    return forms;
-                }
-            });
-        }
-        throw new Error('ask already waiting');
-    }
-    async _setCurrentFlowStep(currentFlowStep, flowStepSchema, force = false) {
-        if (!force) {
-            await this._askToValidateForms();
-        }
-        const schema = deepClone(flowStepSchema);
-        if (currentFlowStep != null) {
-            const configuration = typeof currentFlowStep.step.configuration === 'string'
-                ? JSON.parse(currentFlowStep.step.configuration)
-                : currentFlowStep.step.configuration;
-            const step = { ...currentFlowStep.step, configuration };
-            const _initialValues = { ...step.configuration, commonDescription: step.description, commonCondition: step.condition };
-            this._currentFlowStep = { ...currentFlowStep, step, _initialValues };
-            if (flowStepSchema && flowStepSchema.properties.scope) {
-                const _enum = schema.properties.scope.enum;
-                if (_enum.find((scope) => ['REQUEST', 'REQUEST_CONTENT', 'RESPONSE', 'RESPONSE_CONTENT'].includes(scope)) != null) {
-                    const filtered = this._currentFlowStep.group === 'pre' ? ['REQUEST', 'REQUEST_CONTENT'] : ['RESPONSE', 'RESPONSE_CONTENT'];
-                    schema.properties.scope.enum = _enum.filter((scope) => filtered.includes(scope));
-                    const scope = this._currentFlowStep.step.configuration.scope;
-                    if (scope == null || !schema.properties.scope.enum.includes(scope)) {
-                        schema.properties.scope.default = schema.properties.scope.enum[0];
-                        this._currentFlowStep.step.configuration.scope = schema.properties.scope.enum[0];
-                        this._currentFlowStep._initialValues.scope = schema.properties.scope.enum[0];
-                        if (this._currentFlowStep._values) {
-                            this._currentFlowStep._values.scope = schema.properties.scope.enum[0];
+                    }
+                    else {
+                        this._currentAskConfirmation = null;
+                        return forms;
+                    }
+                });
+            }
+            throw new Error('ask already waiting');
+        });
+    }
+    _setCurrentFlowStep(currentFlowStep, flowStepSchema, force = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!force) {
+                yield this._askToValidateForms();
+            }
+            const schema = deepClone(flowStepSchema);
+            if (currentFlowStep != null) {
+                const configuration = typeof currentFlowStep.step.configuration === 'string'
+                    ? JSON.parse(currentFlowStep.step.configuration)
+                    : currentFlowStep.step.configuration;
+                const step = Object.assign(Object.assign({}, currentFlowStep.step), { configuration });
+                const _initialValues = Object.assign(Object.assign({}, step.configuration), { commonDescription: step.description, commonCondition: step.condition });
+                this._currentFlowStep = Object.assign(Object.assign({}, currentFlowStep), { step, _initialValues });
+                if (flowStepSchema && flowStepSchema.properties.scope) {
+                    const _enum = schema.properties.scope.enum;
+                    if (_enum.find((scope) => ['REQUEST', 'REQUEST_CONTENT', 'RESPONSE', 'RESPONSE_CONTENT'].includes(scope)) != null) {
+                        const filtered = this._currentFlowStep.group === 'pre' ? ['REQUEST', 'REQUEST_CONTENT'] : ['RESPONSE', 'RESPONSE_CONTENT'];
+                        schema.properties.scope.enum = _enum.filter((scope) => filtered.includes(scope));
+                        const scope = this._currentFlowStep.step.configuration.scope;
+                        if (scope == null || !schema.properties.scope.enum.includes(scope)) {
+                            schema.properties.scope.default = schema.properties.scope.enum[0];
+                            this._currentFlowStep.step.configuration.scope = schema.properties.scope.enum[0];
+                            this._currentFlowStep._initialValues.scope = schema.properties.scope.enum[0];
+                            if (this._currentFlowStep._values) {
+                                this._currentFlowStep._values.scope = schema.properties.scope.enum[0];
+                            }
                         }
                     }
                 }
             }
-        }
-        else {
-            this._currentFlowStep = null;
-        }
-        this._flowStepSchema = schema;
+            else {
+                this._currentFlowStep = null;
+            }
+            this._flowStepSchema = schema;
+        });
     }
     _refresh(closeStepForm = true) {
         if (closeStepForm) {
@@ -732,32 +752,36 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         }
         this._definition = deepClone(this._definition);
     }
-    async _onSelectFlows({ detail }) {
-        try {
-            await this._closeFlowStepForm();
-            this._onCloseDocumentation();
-            this._updateSelectedFlows(detail.flows);
-            this._onDesign();
-        }
-        catch (e) {
-            this._currentAskConfirmation = null;
-        }
+    _onSelectFlows({ detail }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._closeFlowStepForm();
+                this._onCloseDocumentation();
+                this._updateSelectedFlows(detail.flows);
+                this._onDesign();
+            }
+            catch (e) {
+                this._currentAskConfirmation = null;
+            }
+        });
     }
-    async _onOpenDocumentationFromMenu({ detail: { policy } }) {
-        try {
-            if (this.documentation == null || this.documentation.id !== policy.id) {
-                await this._closeFlowStepForm();
-                this._currentPolicyId = policy.id;
-                if (this.getSelectedFlow()) {
-                    this._splitMainViews();
-                }
-                else {
-                    this._maximizeBottomView();
+    _onOpenDocumentationFromMenu({ detail: { policy } }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.documentation == null || this.documentation.id !== policy.id) {
+                    yield this._closeFlowStepForm();
+                    this._currentPolicyId = policy.id;
+                    if (this.getSelectedFlow()) {
+                        this._splitMainViews();
+                    }
+                    else {
+                        this._maximizeBottomView();
+                    }
+                    dispatchCustomEvent(this, 'fetch-documentation', { policy });
                 }
-                dispatchCustomEvent(this, 'fetch-documentation', { policy });
             }
-        }
-        catch (e) { }
+            catch (e) { }
+        });
     }
     _fetchDocumentation(policy) {
         if (this.documentation == null || this.documentation.id !== policy.id) {
@@ -798,7 +822,7 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         this._currentFlowStep._values = detail.values;
     }
     _writeFlowStep(values) {
-        const { commonDescription, commonCondition, ...configuration } = values;
+        const { commonDescription, commonCondition } = values, configuration = __rest(values, ["commonDescription", "commonCondition"]);
         if (this._currentFlowStep.step._new ||
             this._currentFlowStep.step.description !== commonDescription ||
             this._currentFlowStep.step.condition !== commonCondition ||
@@ -816,10 +840,12 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             this._currentFlowStep.step = flow[this._currentFlowStep.group][position];
         }
     }
-    async _onSubmitFlowStep({ detail }) {
-        this._writeFlowStep(detail.values);
-        await this.requestUpdate('_definition');
-        this.getChildren().forEach((c) => c.requestUpdate());
+    _onSubmitFlowStep({ detail }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._writeFlowStep(detail.values);
+            yield this.requestUpdate('_definition');
+            this.getChildren().forEach((c) => c.requestUpdate());
+        });
     }
     _onCancelFlow() {
         this._onDesign();
@@ -845,29 +871,31 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
     _onChangeTab({ detail }) {
         this._changeTab(detail.value);
     }
-    async _changeTabValidator({ from, to }) {
-        if (from === 'properties') {
-            const component = this.shadowRoot.querySelector('gv-properties');
-            if (component.dirty) {
-                return component.confirm();
-            }
-        }
-        else if (from === 'resources') {
-            const component = this.shadowRoot.querySelector('gv-resources');
-            if (component.dirty) {
-                return component.confirm();
+    _changeTabValidator({ from, to }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (from === 'properties') {
+                const component = this.shadowRoot.querySelector('gv-properties');
+                if (component.dirty) {
+                    return component.confirm();
+                }
             }
-        }
-        else {
-            try {
-                return await this._askToValidateForms();
+            else if (from === 'resources') {
+                const component = this.shadowRoot.querySelector('gv-resources');
+                if (component.dirty) {
+                    return component.confirm();
+                }
             }
-            catch (e) {
-                this._currentAskConfirmation = null;
-                throw e;
+            else {
+                try {
+                    return yield this._askToValidateForms();
+                }
+                catch (e) {
+                    this._currentAskConfirmation = null;
+                    throw e;
+                }
             }
-        }
-        return Promise.resolve();
+            return Promise.resolve();
+        });
     }
     _changeTab(tabId) {
         if (this._currentAskConfirmation == null) {
@@ -997,7 +1025,7 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
                     }
                 }
                 if (force || e._id == null) {
-                    return { ...e, _id };
+                    return Object.assign(Object.assign({}, e), { _id });
                 }
                 return e;
             });
@@ -1010,9 +1038,14 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             ...Array.from(this.shadowRoot.querySelectorAll('gv-resizable-views')),
         ];
     }
-    async getUpdateComplete() {
-        await super.getUpdateComplete();
-        await Promise.all(this.getChildren().map((e) => e.updateComplete));
+    getUpdateComplete() {
+        const _super = Object.create(null, {
+            getUpdateComplete: { get: () => super.getUpdateComplete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.getUpdateComplete.call(this);
+            yield Promise.all(this.getChildren().map((e) => e.updateComplete));
+        });
     }
     shouldUpdate(changedProperties) {
         // Just refresh gv-flow components
@@ -1033,7 +1066,13 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
     }
     _renderFlowStepForm(readonlyMode) {
         const values = this._currentFlowStep._values || this._currentFlowStep._initialValues;
-        const groups = [{ items: ['commonDescription', 'commonCondition'] }, { name: i18n('gv-policy-studio.policy-settings'), default: true }];
+        const groups = [
+            { items: ['commonDescription', 'commonCondition'] },
+            {
+                name: i18n('gv-policy-studio.policy-settings'),
+                default: true,
+            },
+        ];
         return html `${cache(this._flowStepSchema && this._currentFlowStep
             ? html `<div class="flow-step__container">
             <div class="flow-step__form">
@@ -1103,33 +1142,35 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
     get definedProperties() {
         return this._definition && this._definition.properties ? this._definition.properties : [];
     }
-    async _onDuplicateFlow({ detail }) {
-        try {
-            await this._askToValidateForms();
-            const flowId = detail.content._id;
-            const { plan, flows } = this._findFlowCollection(flowId);
-            this._addFlow(flows, this._findFlowById(flowId));
-            if (plan != null) {
-                let planIndex = null;
-                this.definedPlans.find((p, i) => {
-                    if (p.id === plan.id) {
-                        planIndex = i;
-                        return true;
-                    }
-                    return false;
-                });
-                plan.flows = flows;
-                this.definedPlans[planIndex].flows = this._generatePlanFlowsId(plan, true);
-                this._updateSelectedFlows([this.definedPlans[planIndex].flows[flows.length - 1]._id]);
+    _onDuplicateFlow({ detail }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._askToValidateForms();
+                const flowId = detail.content._id;
+                const { plan, flows } = this._findFlowCollection(flowId);
+                this._addFlow(flows, this._findFlowById(flowId));
+                if (plan != null) {
+                    let planIndex = null;
+                    this.definedPlans.find((p, i) => {
+                        if (p.id === plan.id) {
+                            planIndex = i;
+                            return true;
+                        }
+                        return false;
+                    });
+                    plan.flows = flows;
+                    this.definedPlans[planIndex].flows = this._generatePlanFlowsId(plan, true);
+                    this._updateSelectedFlows([this.definedPlans[planIndex].flows[flows.length - 1]._id]);
+                }
+                else {
+                    this._definition.flows = this._generateFlowsId(this._definition.flows);
+                    this._updateSelectedFlows([this._definition.flows[this._definition.flows.length - 1]._id]);
+                }
             }
-            else {
-                this._definition.flows = this._generateFlowsId(this._definition.flows);
-                this._updateSelectedFlows([this._definition.flows[this._definition.flows.length - 1]._id]);
+            catch (err) {
+                this._currentAskConfirmation = null;
             }
-        }
-        catch (err) {
-            this._currentAskConfirmation = null;
-        }
+        });
     }
     _onChangeFlowState({ detail }) {
         const flow = this._findFlowById(detail.content._id);
@@ -1137,38 +1178,38 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         flow._dirty = true;
         this.isDirty = true;
     }
-    async _onAddFlowPlan({ detail }) {
-        try {
-            await this._askToValidateForms();
-            this._addFlow(this.definedPlans[detail.planIndex].flows);
-            this.definedPlans[detail.planIndex].flows = this._generatePlanFlowsId(this.definedPlans[detail.planIndex]);
-            this._updateSelectedFlows([this.definedPlans[detail.planIndex].flows[this.definedPlans[detail.planIndex].flows.length - 1]._id]);
-        }
-        catch (err) {
-            this._currentAskConfirmation = null;
-        }
+    _onAddFlowPlan({ detail }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._askToValidateForms();
+                this._addFlow(this.definedPlans[detail.planIndex].flows);
+                this.definedPlans[detail.planIndex].flows = this._generatePlanFlowsId(this.definedPlans[detail.planIndex]);
+                this._updateSelectedFlows([this.definedPlans[detail.planIndex].flows[this.definedPlans[detail.planIndex].flows.length - 1]._id]);
+            }
+            catch (err) {
+                this._currentAskConfirmation = null;
+            }
+        });
     }
-    async _onAddFlow() {
-        try {
-            await this._askToValidateForms();
-            this._addFlow(this._definition.flows);
-            this._definition.flows = this._generateFlowsId(this._definition.flows);
-            this._updateSelectedFlows([this._definition.flows[this._definition.flows.length - 1]._id]);
-        }
-        catch (err) {
-            this._currentAskConfirmation = null;
-        }
+    _onAddFlow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._askToValidateForms();
+                this._addFlow(this._definition.flows);
+                this._definition.flows = this._generateFlowsId(this._definition.flows);
+                this._updateSelectedFlows([this._definition.flows[this._definition.flows.length - 1]._id]);
+            }
+            catch (err) {
+                this._currentAskConfirmation = null;
+            }
+        });
     }
     _addFlow(collection, duplicate = null) {
         const flow = duplicate == null
             ? this._createFlowFromSchema()
-            : {
-                ...duplicate,
-                _id: null,
+            : Object.assign(Object.assign({}, duplicate), { _id: null, 
                 // reset the id to avoid issue with AM that persists the ID
-                id: null,
-                _dirty: true,
-            };
+                id: null, _dirty: true });
         collection.push(flow);
         this.isDirty = true;
         return collection;
@@ -1183,7 +1224,7 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         return this._instantiate(this.flowSchema.properties, newFlow);
     }
     _instantiate(propertiesDefinition, initiator = {}) {
-        const property = { ...initiator };
+        const property = Object.assign({}, initiator);
         if (propertiesDefinition) {
             for (const key of Object.keys(propertiesDefinition)) {
                 const entry = propertiesDefinition[key];
@@ -1225,34 +1266,36 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
         });
         return index;
     }
-    async _onReorderFlows({ detail: { plan } }) {
-        try {
-            await this._askToValidateForms();
-            this.isDirty = true;
-            if (plan != null) {
-                const newOrder = this._generatePlanFlowsId(plan, true);
-                if (this.selectedFlowsId) {
-                    this._updateSelectedFlows(this.selectedFlowsId.map((flowId) => {
-                        const index = this._findFlowIndex(plan.flows, flowId);
-                        return index != null ? newOrder[index]._id : flowId;
-                    }));
+    _onReorderFlows({ detail: { plan } }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._askToValidateForms();
+                this.isDirty = true;
+                if (plan != null) {
+                    const newOrder = this._generatePlanFlowsId(plan, true);
+                    if (this.selectedFlowsId) {
+                        this._updateSelectedFlows(this.selectedFlowsId.map((flowId) => {
+                            const index = this._findFlowIndex(plan.flows, flowId);
+                            return index != null ? newOrder[index]._id : flowId;
+                        }));
+                    }
+                    plan.flows = newOrder;
                 }
-                plan.flows = newOrder;
-            }
-            else {
-                const newOrder = this._generateFlowsId(this._definition.flows, true);
-                if (this.selectedFlowsId) {
-                    this._updateSelectedFlows(this.selectedFlowsId.map((flowId) => {
-                        const index = this._findFlowIndex(this._definition.flows, flowId);
-                        return index != null ? newOrder[index]._id : flowId;
-                    }));
+                else {
+                    const newOrder = this._generateFlowsId(this._definition.flows, true);
+                    if (this.selectedFlowsId) {
+                        this._updateSelectedFlows(this.selectedFlowsId.map((flowId) => {
+                            const index = this._findFlowIndex(this._definition.flows, flowId);
+                            return index != null ? newOrder[index]._id : flowId;
+                        }));
+                    }
+                    this._definition.flows = newOrder;
                 }
-                this._definition.flows = newOrder;
             }
-        }
-        catch (err) {
-            this._currentAskConfirmation = false;
-        }
+            catch (err) {
+                this._currentAskConfirmation = false;
+            }
+        });
     }
     _onSearchPolicy({ detail }) {
         this._searchPolicyQuery = detail;
@@ -1266,20 +1309,22 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
     _onClearFlows() {
         this._searchFlowQuery = null;
     }
-    async _onResetAll() {
-        try {
-            await this._closeFlowStepForm();
-            this.definition = deepClone(this._initialDefinition);
-        }
-        catch (e) {
-            this._currentAskConfirmation = null;
-        }
+    _onResetAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._closeFlowStepForm();
+                this.definition = deepClone(this._initialDefinition);
+            }
+            catch (e) {
+                this._currentAskConfirmation = null;
+            }
+        });
     }
     _filterNotValidStep(step) {
         return step._new !== true;
     }
     _removePrivateProperties(o) {
-        const copy = { ...o };
+        const copy = Object.assign({}, o);
         Object.keys(o)
             .filter((key) => key.startsWith('_'))
             .forEach((key) => {
@@ -1304,21 +1349,23 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
     getPropertiesElement() {
         return this.shadowRoot.querySelector('gv-properties');
     }
-    async _checkCurrentFlowStep() {
-        if (this._currentFlowStep && this.selectedFlowsId) {
-            const closePromises = this.selectedFlowsId
-                .map((flowId) => {
-                const flow = this._findFlowById(flowId);
-                const currentStep = [...flow.pre, ...flow.post].find((step) => step._id === this._currentFlowStep.step._id);
-                if (currentStep == null) {
-                    return this._closeFlowStepForm(true);
-                }
-                return null;
-            })
-                .filter((p) => p !== null);
-            return Promise.all(closePromises);
-        }
-        return Promise.resolve();
+    _checkCurrentFlowStep() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._currentFlowStep && this.selectedFlowsId) {
+                const closePromises = this.selectedFlowsId
+                    .map((flowId) => {
+                    const flow = this._findFlowById(flowId);
+                    const currentStep = [...flow.pre, ...flow.post].find((step) => step._id === this._currentFlowStep.step._id);
+                    if (currentStep == null) {
+                        return this._closeFlowStepForm(true);
+                    }
+                    return null;
+                })
+                    .filter((p) => p !== null);
+                return Promise.all(closePromises);
+            }
+            return Promise.resolve();
+        });
     }
     saved() {
         if (this.isDirty) {
@@ -1342,7 +1389,7 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             flow.post = flow.post.filter(this._filterNotValidStep);
             return flow;
         });
-        let definition = { ...this._definition, flows };
+        let definition = Object.assign(Object.assign({}, this._definition), { flows });
         if (this._definition.plans != null) {
             const plans = this._definition.plans.map((plan) => {
                 const flows = plan.flows.map((flow) => {
@@ -1350,9 +1397,9 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
                     flow.post = flow.post.filter(this._filterNotValidStep);
                     return flow;
                 });
-                return { ...plan, flows };
+                return Object.assign(Object.assign({}, plan), { flows });
             });
-            definition = { ...definition, plans };
+            definition = Object.assign(Object.assign({}, definition), { plans });
         }
         return definition;
     }
@@ -1364,7 +1411,7 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
             flow.post = flow.post.map(this._removePrivateProperties);
             return flow;
         });
-        let definition = { ...this._definition, flows };
+        let definition = Object.assign(Object.assign({}, this._definition), { flows });
         if (this._definition.plans != null) {
             const plans = definitionToSave.plans.map((plan) => {
                 const flows = plan.flows.map((f) => {
@@ -1373,17 +1420,17 @@ export class GvPolicyStudio extends KeyboardElement(LitElement) {
                     flow.post = flow.post.map(this._removePrivateProperties);
                     return flow;
                 });
-                return { ...plan, flows };
+                return Object.assign(Object.assign({}, plan), { flows });
             });
-            definition = { ...definition, plans };
+            definition = Object.assign(Object.assign({}, definition), { plans });
         }
         if (this._definition.properties != null) {
             const properties = this._definition.properties.map(this._removePrivateProperties);
-            definition = { ...definition, properties };
+            definition = Object.assign(Object.assign({}, definition), { properties });
         }
         if (this._definition.resources != null) {
             const resources = this._definition.resources.map(this._removePrivateProperties);
-            definition = { ...definition, resources };
+            definition = Object.assign(Object.assign({}, definition), { resources });
         }
         return definition;
     }