ng-configcat-publicapi-ui 3.0.8 → 4.0.0

package/esm2022/lib/v2/feature-flag-item.component.mjs

@@ -0,0 +1,319 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { BaseComponent } from '../base/base.component';
+import { FormArray, FormControl, Validators } from '@angular/forms';
+import { forkJoin, throwError } from 'rxjs';
+import { ConfirmationDialogComponent } from '../dialogs/confirmation-dialog/confirmation-dialog';
+import { ReasonDialogComponent } from '../dialogs/reason-dialog/reason-dialog.component';
+import { SaveSnackbarComponent } from '../dialogs/save-snackbar/save-snackbar.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../_services/form-generator";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "@angular/material/snack-bar";
+import * as i4 from "../_services";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "./feature-flag/feature-flag.component";
+import * as i10 from "../_services/tracking.directive";
+export class FeatureFlagItemComponent extends BaseComponent {
+    constructor(formGenerator, dialog, snackBar, publicApiService) {
+        super(publicApiService);
+        this.formGenerator = formGenerator;
+        this.dialog = dialog;
+        this.snackBar = snackBar;
+        this.canDeleteSetting = true;
+        this.deleteSettingText = 'Delete setting';
+        this.showEnvironmentName = true;
+        this.deleteSettingRequested = new EventEmitter();
+        this.loadSucceeded = new EventEmitter();
+        this.loadFailed = new EventEmitter();
+        this.saveSucceeded = new EventEmitter();
+        this.saveFailed = new EventEmitter();
+        this.expandedStateChanged = new EventEmitter();
+        this.formValuesChanged = new EventEmitter();
+        this.loading = true;
+        this.showFeedBackMessage = false;
+        this.hasSettingValues = false;
+        this.hasOtherEnvironment = false;
+    }
+    ngOnInit() {
+        this.reloadSettingValues();
+    }
+    ngOnDestroy() {
+        this.unsubscribeFormValueChangesSubscription();
+    }
+    reloadSettingValues() {
+        this.loading = true;
+        this.createSettingValuesV2Service();
+        forkJoin({
+            segments: this.createSegmentsService().getSegments(this.productId),
+            settings: this.createSettingsService().getSettings(this.configId),
+            settingFormula: this.createSettingValuesV2Service().getSettingValueV2(this.environmentId, this.settingId)
+        }).subscribe(result => {
+            this.settings = result.settings;
+            this.prerequisiteSettings = this.settings.map(sv => {
+                return {
+                    settingId: sv.settingId,
+                    key: sv.key,
+                    name: sv.name,
+                    settingType: sv.settingType
+                };
+            });
+            this.segments = result.segments;
+            this.handleFetchedSettingValues(result.settingFormula);
+            this.loading = false;
+            this.loadSucceeded.emit();
+        }, (error) => {
+            this.loadFailed.emit(error);
+            return throwError(error);
+        });
+    }
+    handleFetchedSettingValues(model) {
+        this.settingFormula = model;
+        // when we have less we had previously
+        this.flagState = {
+            addButtonRenderState: {
+                hasPercentageOnlyRule: false,
+                renderTopAddButtons: false,
+                addRuleButtonTracker: []
+            },
+            readOnly: model.readOnly,
+            dependeeSettings: [],
+            settingValue: model,
+            panelExpanded: true,
+            prerequisiteSettings: this.getAvailablePrerequisiteSettings(model.setting.settingId)
+        };
+        this.unsubscribeFormValueChangesSubscription();
+        this.createFormGroupFromState(this.settingFormula);
+        this.formValueChangesSubscription = this.formGroup.valueChanges.subscribe(() => {
+            this.formValuesChanged.emit();
+        });
+        this.recalcAddButtons();
+        this.recalcPrerequisites();
+    }
+    unsubscribeFormValueChangesSubscription() {
+        if (this.formValueChangesSubscription) {
+            this.formValueChangesSubscription.unsubscribe();
+            this.formValueChangesSubscription = null;
+        }
+    }
+    createFormGroupFromState(model) {
+        this.formGroup = this.formGenerator.generateSettingValuesFormGroup(model, model.readOnly, this.prerequisiteSettings, model.featureFlagLimitations);
+    }
+    getAvailablePrerequisiteSettings(settingId) {
+        return this.prerequisiteSettings.filter(ds => ds.settingId !== settingId);
+    }
+    revert() {
+        const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
+            data: {
+                title: 'Revert to last saved state?',
+                body: 'All changes will be lost.',
+                yesButtonLabel: 'Revert',
+                noButtonLabel: 'No'
+            }
+        });
+        dialogRef.afterClosed().subscribe(result => {
+            if (result === 'yes') {
+                this.revertDirtyValuesFromState();
+            }
+        });
+    }
+    revertDirtyValuesFromState() {
+        if (this.formGroup.dirty) {
+            this.formGroup.setControl('defaultValue', this.formGenerator.generateValueFormGroup(this.settingFormula.defaultValue, this.settingFormula.setting.settingType, this.settingFormula.readOnly, this.settingFormula.featureFlagLimitations));
+            this.formGroup.setControl('percentageEvaluationAttribute', new FormControl({ value: this.settingFormula.percentageEvaluationAttribute, disabled: this.settingFormula.readOnly }, { validators: [Validators.max(1000)] }));
+            this.formGroup.setControl('targetingRules', new FormArray(this.settingFormula.targetingRules.map(ft => this.formGenerator.generateTargetingRuleFormGroup(ft, this.settingFormula.setting.settingType, this.settingFormula.readOnly, this.prerequisiteSettings, this.settingFormula.featureFlagLimitations))));
+            this.recalcAddButtons();
+        }
+        this.formGroup.markAsPristine();
+        this.formGroup.markAsUntouched();
+        this.recalcPrerequisites();
+        this.showFeedBackMessage = false;
+    }
+    submit() {
+        if (!this.formGroup) {
+            return;
+        }
+        if (!this.formGroup.valid) {
+            this.showFeedBackMessage = true;
+            this.formGroup.markAllAsTouched();
+            return;
+        }
+        this.showFeedBackMessage = false;
+        const value = {
+            ...this.formGroup.getRawValue(),
+        };
+        this.updateSettingValues(value);
+    }
+    updateSettingValues(updateModel, reason = null) {
+        this.createSettingValuesV2Service().replaceSettingValueV2(this.environmentId, this.settingId, updateModel, reason)
+            .subscribe({
+            next: settingValues => {
+                this.handleFetchedSettingValues(settingValues);
+                this.snackBar.openFromComponent(SaveSnackbarComponent, { duration: 5000, panelClass: 'green-snackbar' });
+                this.saveSucceeded.emit();
+            },
+            error: (error) => {
+                if (error.status === 400 && error.error && error.error.Reason && error.error.Reason[0] === 'Reason required.') {
+                    const dialogRef = this.dialog.open(ReasonDialogComponent, {
+                        width: '450px'
+                    });
+                    dialogRef.afterClosed()
+                        .subscribe(result => {
+                        if (result && result.button === 'save' && result.reason) {
+                            this.updateSettingValues(updateModel, result.reason);
+                        }
+                    });
+                    return;
+                }
+                if (error.status === 400 && error.error && error.error.SegmentCondition && error.error.SegmentCondition[0] === 'Segment not found.') {
+                    const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
+                        width: '450px',
+                        data: {
+                            title: 'Cannot save feature flags',
+                            body: 'A segment referenced by one of your feature flags has been deleted. Reload the config to see its latest state, apply your changes and try the save again.',
+                            yesButtonLabel: 'Reload',
+                            hideNoButton: true
+                        }
+                    });
+                    dialogRef.afterClosed()
+                        .subscribe(() => {
+                        this.reloadSettingValues();
+                    });
+                    return;
+                }
+                if (error.status === 400 && error.error && ('' + error.error).startsWith('Circular dependency detected.')) {
+                    const errorMessage = ('' + error.error).slice('Circular dependency detected.'.length + 1);
+                    this.dialog.open(ConfirmationDialogComponent, {
+                        width: '450px',
+                        data: {
+                            title: 'Cannot save feature flags.',
+                            body: 'Circular dependency detected between the following feature flags:<p>' + errorMessage + '</p>Please <strong>eliminate the circular dependency</strong> before saving your feature flags.',
+                            yesButtonLabel: 'I understand',
+                            hideNoButton: true
+                        }
+                    });
+                    return;
+                }
+                this.formGroup.setErrors({ internalServerError: 'Internal server error' });
+                this.formGroup.markAsTouched();
+                this.showFeedBackMessage = true;
+                this.saveFailed.emit();
+            }
+        });
+    }
+    onDeleteSettingRequested(setting) {
+        if (this.formGroup.dirty) {
+            const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
+                data: {
+                    title: 'Discard changes?',
+                    body: 'You have unsaved feature flag changes. If you continue, unsaved changes will be lost.',
+                    yesButtonLabel: 'Discard changes',
+                    noButtonLabel: 'No'
+                }
+            });
+            dialogRef.afterClosed()
+                .subscribe(result => {
+                if (result === 'yes') {
+                    this.revertDirtyValuesFromState();
+                    this.deleteSettingInternal(setting);
+                }
+            });
+        }
+        else {
+            this.deleteSettingInternal(setting);
+        }
+    }
+    deleteSettingInternal(setting) {
+        this.deleteSettingRequested.emit({ config: this.settingFormula.config, environment: this.settingFormula.environment, setting: setting.setting });
+    }
+    subscriptionLimitReachedCalled() {
+        // TODO this.subscriptionLimitReached(this.constellation, this.dialog);
+    }
+    addSegmentConditionRequestedWithoutSegments() {
+        this.dialog.open(ConfirmationDialogComponent, {
+            data: {
+                title: 'There are no segments in this product yet.',
+                body: `Go ahead to the ConfiCat Dashboard and create your first user segment before adding it to a targeting rule.`,
+                yesButtonLabel: `I understand`
+            }
+        });
+    }
+    trackByIndex(index) {
+        return index;
+    }
+    recalcPrerequisites() {
+        const settingValue = this.settingFormula;
+        this.flagState.dependeeSettings = this.settings.filter(s => settingValue.settingIdsWherePrerequisite?.includes(s.settingId))
+            .map(s => { return { key: s.key, name: s.name, settingId: s.settingId }; });
+        return;
+    }
+    recalcAddButtons() {
+        const state = this.flagState;
+        const group = this.formGroup;
+        state.addButtonRenderState.renderTopAddButtons = !group.controls.targetingRules.controls.length ||
+            this.hasOnlyPercentageRule(group);
+        if (!group.controls.targetingRules.controls.length) {
+            state.addButtonRenderState.addRuleButtonTracker = [];
+            state.addButtonRenderState.hasPercentageOnlyRule = false;
+        }
+        else {
+            const hasPercOnly = state.addButtonRenderState.hasPercentageOnlyRule = group.controls.targetingRules.controls.length > 0
+                && this.formGenerator.isPercentageOnlyTargetingRule(group.controls.targetingRules.controls[group.controls.targetingRules.controls.length - 1]);
+            state.addButtonRenderState.addRuleButtonTracker = group.controls.targetingRules.controls.map((item, i, rules) => {
+                const isLastRule = i === group.controls.targetingRules.controls.length - 1;
+                const isBeforeLast = i === group.controls.targetingRules.controls.length - 2;
+                return {
+                    showAddRuleButtons: hasPercOnly ? i === rules.length - 2 : i === rules.length - 1,
+                    showOrChip: hasPercOnly ? i < rules.length - 2 : i < rules.length - 1,
+                    renderSeparationArea: this.formGenerator.isPercentageOnlyTargetingRule(item) ||
+                        (this.settingFormula.readOnly && (isLastRule || (hasPercOnly && isBeforeLast))),
+                };
+            });
+        }
+    }
+    hasOnlyPercentageRule(group) {
+        return group.controls.targetingRules.controls.length === 1 &&
+            this.formGenerator.isPercentageOnlyTargetingRule(group.controls.targetingRules.controls[0]);
+    }
+    expandedChanged(expandedState) {
+        this.flagState.panelExpanded = expandedState;
+        this.expandedStateChanged.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: FeatureFlagItemComponent, deps: [{ token: i1.FormGenerator }, { token: i2.MatDialog }, { token: i3.MatSnackBar }, { token: i4.PublicApiService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.3", type: FeatureFlagItemComponent, selector: "configcat-feature-flag-item", inputs: { productId: "productId", environmentId: "environmentId", configId: "configId", settingId: "settingId", canDeleteSetting: "canDeleteSetting", deleteSettingText: "deleteSettingText", showEnvironmentName: "showEnvironmentName" }, outputs: { deleteSettingRequested: "deleteSettingRequested", loadSucceeded: "loadSucceeded", loadFailed: "loadFailed", saveSucceeded: "saveSucceeded", saveFailed: "saveFailed", expandedStateChanged: "expandedStateChanged", formValuesChanged: "formValuesChanged" }, usesInheritance: true, ngImport: i0, template: "<div class=\"container\">\n    <ng-container *ngIf=\"!loading\">\n        <form [formGroup]=\"formGroup\" (ngSubmit)=\"submit()\" id=\"feature-flag-form\">\n            <div [ngClass]=\"{'invalid-flag': formGroup.invalid}\">\n                <app-feature-flag [formGroup]=\"formGroup\" [flagState]=\"flagState\" [segments]=\"segments\"\n                    (deleteSettingRequested)=\"onDeleteSettingRequested($event)\"\n                    [featureFlagLimitations]=\"settingFormula.featureFlagLimitations\" [hasOtherEnvironment]=\"false\"\n                    (subscriptionLimitReached)=\"subscriptionLimitReachedCalled()\"\n                    (addSegmentConditionRequestedWithoutSegments)=\"addSegmentConditionRequestedWithoutSegments()\"\n                    (prerequisiteConditionChanged)=\"recalcPrerequisites()\" (recalcAddButtons)=\"recalcAddButtons()\"\n                    (expandedChanged)=\"expandedChanged($event)\"\n                    [showEnvironmentName]=\"showEnvironmentName\" [environmentName]=\"settingFormula.environment.name\"\n                    [deleteSettingText]=\"deleteSettingText\">\n                </app-feature-flag>\n            </div>\n            <div class=\"save\" *ngIf=\"!settingFormula.readOnly && formGroup?.dirty\">\n                <button class=\"save-button\" mat-flat-button color=\"warn\" type=\"submit\" [class.animate]=\"formGroup.dirty\"\n                    [track]=\"['save & publish click', 'feature flags and settings']\">\n                    <mat-icon>backup</mat-icon> <span> Save & publish changes</span>\n                </button>\n                <button type=\"button\" class=\"revert-button\" mat-stroked-button (click)=\"revert()\"\n                    [track]=\"['revert click', 'feature flags and settings']\">\n                    <span>Revert</span>\n                </button>\n                <div class=\"feedback\" *ngIf=\"formGroup.touched && formGroup.invalid && showFeedBackMessage\">\n                    <div class=\"error\" *ngIf=\"formGroup.errors && formGroup.errors.internalServerError\">\n                        <span>Something went wrong and we could not save your settings. You can try again or <a\n                                href=\"https://configcat.com/support\" target=\"_blank\" rel=\"noopener noreferrer\">contact\n                                us.</a></span>\n                    </div>\n                    <div class=\"error\" *ngIf=\"!formGroup.errors || !formGroup.errors.internalServerError\">\n                        <span>Oh no! A feature flag has invalid or missing data.&nbsp;</span>\n                    </div>\n                </div>\n            </div>\n        </form>\n\n    </ng-container>\n</div>", styles: [".container .expand-collapse{--mdc-text-button-container-height: 24px;--mdc-filled-button-container-height: 24px;--mdc-outlined-button-container-height: 24px;--mdc-protected-button-container-height: 24px;margin-left:auto;margin-top:.3rem;display:flex;flex-wrap:nowrap}.container .expand-collapse .mat-mdc-button .mat-mdc-button-touch-target,.container .expand-collapse .mat-mdc-raised-button .mat-mdc-button-touch-target,.container .expand-collapse .mat-mdc-unelevated-button .mat-mdc-button-touch-target,.container .expand-collapse .mat-mdc-outlined-button .mat-mdc-button-touch-target{display:none}.container .expand-collapse .btn{font-size:.6em;padding:0 8px;min-width:105px}.container .expand-collapse .btn mat-icon{font-size:14px;width:14px;height:14px;margin-right:4px;color:#838383}.container .expand-collapse .expand{margin-right:6px}.container .read-only-notification{margin-top:.6rem}.container .save{position:sticky;bottom:0;background-color:#fff;display:flex;flex-direction:row;flex-wrap:wrap;align-items:center;z-index:999;padding-top:.5rem;padding-bottom:.5rem}.container .save .save-button{animation:shadow-pulse 1s 3}.container .save .save-button:disabled{animation:none}.container .save>*{margin-top:.5rem;margin-bottom:.5rem;margin-right:.6em}.container .error{color:#f44336;padding:5px;font-size:.9em}.container .error a{color:#f44336;text-decoration:underline}@media (max-width: 750px){.expand-collapse{flex-wrap:wrap!important}.expand-collapse .btn{margin-bottom:2px}}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i6.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i6.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i7.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i9.FeatureFlagComponent, selector: "app-feature-flag", inputs: ["formGroup", "flagState", "segments", "featureFlagLimitations", "hasOtherEnvironment", "environmentName", "showEnvironmentName", "deleteSettingText"], outputs: ["addSegmentConditionRequestedWithoutSegments", "expandedChanged", "deleteSettingRequested", "subscriptionLimitReached", "prerequisiteConditionChanged", "recalcAddButtons"] }, { kind: "directive", type: i10.TrackingDirective, selector: "[track]", inputs: ["track"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: FeatureFlagItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'configcat-feature-flag-item', template: "<div class=\"container\">\n    <ng-container *ngIf=\"!loading\">\n        <form [formGroup]=\"formGroup\" (ngSubmit)=\"submit()\" id=\"feature-flag-form\">\n            <div [ngClass]=\"{'invalid-flag': formGroup.invalid}\">\n                <app-feature-flag [formGroup]=\"formGroup\" [flagState]=\"flagState\" [segments]=\"segments\"\n                    (deleteSettingRequested)=\"onDeleteSettingRequested($event)\"\n                    [featureFlagLimitations]=\"settingFormula.featureFlagLimitations\" [hasOtherEnvironment]=\"false\"\n                    (subscriptionLimitReached)=\"subscriptionLimitReachedCalled()\"\n                    (addSegmentConditionRequestedWithoutSegments)=\"addSegmentConditionRequestedWithoutSegments()\"\n                    (prerequisiteConditionChanged)=\"recalcPrerequisites()\" (recalcAddButtons)=\"recalcAddButtons()\"\n                    (expandedChanged)=\"expandedChanged($event)\"\n                    [showEnvironmentName]=\"showEnvironmentName\" [environmentName]=\"settingFormula.environment.name\"\n                    [deleteSettingText]=\"deleteSettingText\">\n                </app-feature-flag>\n            </div>\n            <div class=\"save\" *ngIf=\"!settingFormula.readOnly && formGroup?.dirty\">\n                <button class=\"save-button\" mat-flat-button color=\"warn\" type=\"submit\" [class.animate]=\"formGroup.dirty\"\n                    [track]=\"['save & publish click', 'feature flags and settings']\">\n                    <mat-icon>backup</mat-icon> <span> Save & publish changes</span>\n                </button>\n                <button type=\"button\" class=\"revert-button\" mat-stroked-button (click)=\"revert()\"\n                    [track]=\"['revert click', 'feature flags and settings']\">\n                    <span>Revert</span>\n                </button>\n                <div class=\"feedback\" *ngIf=\"formGroup.touched && formGroup.invalid && showFeedBackMessage\">\n                    <div class=\"error\" *ngIf=\"formGroup.errors && formGroup.errors.internalServerError\">\n                        <span>Something went wrong and we could not save your settings. You can try again or <a\n                                href=\"https://configcat.com/support\" target=\"_blank\" rel=\"noopener noreferrer\">contact\n                                us.</a></span>\n                    </div>\n                    <div class=\"error\" *ngIf=\"!formGroup.errors || !formGroup.errors.internalServerError\">\n                        <span>Oh no! A feature flag has invalid or missing data.&nbsp;</span>\n                    </div>\n                </div>\n            </div>\n        </form>\n\n    </ng-container>\n</div>", styles: [".container .expand-collapse{--mdc-text-button-container-height: 24px;--mdc-filled-button-container-height: 24px;--mdc-outlined-button-container-height: 24px;--mdc-protected-button-container-height: 24px;margin-left:auto;margin-top:.3rem;display:flex;flex-wrap:nowrap}.container .expand-collapse .mat-mdc-button .mat-mdc-button-touch-target,.container .expand-collapse .mat-mdc-raised-button .mat-mdc-button-touch-target,.container .expand-collapse .mat-mdc-unelevated-button .mat-mdc-button-touch-target,.container .expand-collapse .mat-mdc-outlined-button .mat-mdc-button-touch-target{display:none}.container .expand-collapse .btn{font-size:.6em;padding:0 8px;min-width:105px}.container .expand-collapse .btn mat-icon{font-size:14px;width:14px;height:14px;margin-right:4px;color:#838383}.container .expand-collapse .expand{margin-right:6px}.container .read-only-notification{margin-top:.6rem}.container .save{position:sticky;bottom:0;background-color:#fff;display:flex;flex-direction:row;flex-wrap:wrap;align-items:center;z-index:999;padding-top:.5rem;padding-bottom:.5rem}.container .save .save-button{animation:shadow-pulse 1s 3}.container .save .save-button:disabled{animation:none}.container .save>*{margin-top:.5rem;margin-bottom:.5rem;margin-right:.6em}.container .error{color:#f44336;padding:5px;font-size:.9em}.container .error a{color:#f44336;text-decoration:underline}@media (max-width: 750px){.expand-collapse{flex-wrap:wrap!important}.expand-collapse .btn{margin-bottom:2px}}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormGenerator }, { type: i2.MatDialog }, { type: i3.MatSnackBar }, { type: i4.PublicApiService }], propDecorators: { productId: [{
+                type: Input
+            }], environmentId: [{
+                type: Input
+            }], configId: [{
+                type: Input
+            }], settingId: [{
+                type: Input
+            }], canDeleteSetting: [{
+                type: Input
+            }], deleteSettingText: [{
+                type: Input
+            }], showEnvironmentName: [{
+                type: Input
+            }], deleteSettingRequested: [{
+                type: Output
+            }], loadSucceeded: [{
+                type: Output
+            }], loadFailed: [{
+                type: Output
+            }], saveSucceeded: [{
+                type: Output
+            }], saveFailed: [{
+                type: Output
+            }], expandedStateChanged: [{
+                type: Output
+            }], formValuesChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-flag-item.component.js","sourceRoot":"","sources":["../../../../../projects/ng-configcat-publicapi-ui/src/lib/v2/feature-flag-item.component.ts","../../../../../projects/ng-configcat-publicapi-ui/src/lib/v2/feature-flag-item.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,KAAK,EAAE,MAAM,EAAE,YAAY,EAAa,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGvD,OAAO,EAAE,SAAS,EAAE,WAAW,EAAa,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG/E,OAAO,EAAgB,QAAQ,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC1D,OAAO,EAAE,2BAA2B,EAAE,MAAM,oDAAoD,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,kDAAkD,CAAC;AAIzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kDAAkD,CAAC;;;;;;;;;;;;AAQzF,MAAM,OAAO,wBAAyB,SAAQ,aAAa;IAwCzD,YACU,aAA4B,EAC5B,MAAiB,EACjB,QAAqB,EAC7B,gBAAkC;QAElC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QALhB,kBAAa,GAAb,aAAa,CAAe;QAC5B,WAAM,GAAN,MAAM,CAAW;QACjB,aAAQ,GAAR,QAAQ,CAAa;QApCtB,qBAAgB,GAAG,IAAI,CAAC;QACxB,sBAAiB,GAAG,gBAAgB,CAAC;QACrC,wBAAmB,GAAG,IAAI,CAAC;QAE1B,2BAAsB,GAAG,IAAI,YAAY,EAAE,CAAC;QAE5C,kBAAa,GAAG,IAAI,YAAY,EAAE,CAAC;QACnC,eAAU,GAAG,IAAI,YAAY,EAAE,CAAC;QAChC,kBAAa,GAAG,IAAI,YAAY,EAAE,CAAC;QACnC,eAAU,GAAG,IAAI,YAAY,EAAE,CAAC;QAChC,yBAAoB,GAAG,IAAI,YAAY,EAAE,CAAC;QAC1C,sBAAiB,GAAG,IAAI,YAAY,EAAE,CAAC;QAIjD,YAAO,GAAG,IAAI,CAAC;QAYf,wBAAmB,GAAG,KAAK,CAAC;QAE5B,qBAAgB,GAAG,KAAK,CAAC;QAEzB,wBAAmB,GAAG,KAAK,CAAC;IAS5B,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,uCAAuC,EAAE,CAAC;IACjD,CAAC;IAED,mBAAmB;QAEjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,4BAA4B,EAAE,CAAA;QAEnC,QAAQ,CAAC;YACP,QAAQ,EAAE,IAAI,CAAC,qBAAqB,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC;YAClE,QAAQ,EAAE,IAAI,CAAC,qBAAqB,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjE,cAAc,EAAE,IAAI,CAAC,4BAA4B,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,CAAC;SAC1G,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YACpB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAChC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;gBACjD,OAAO;oBACL,SAAS,EAAE,EAAE,CAAC,SAAS;oBACvB,GAAG,EAAE,EAAE,CAAC,GAAG;oBACX,IAAI,EAAE,EAAE,CAAC,IAAI;oBACb,WAAW,EAAE,EAAE,CAAC,WAAW;iBAC5B,CAAA;YACH,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAChC,IAAI,CAAC,0BAA0B,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;YACvD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC5B,CAAC,EACC,CAAC,KAAK,EAAE,EAAE;YACR,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC5B,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;IACP,CAAC;IAED,0BAA0B,CAAC,KAA0B;QACnD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,sCAAsC;QACtC,IAAI,CAAC,SAAS,GAAG;YACf,oBAAoB,EAAE;gBACpB,qBAAqB,EAAE,KAAK;gBAC5B,mBAAmB,EAAE,KAAK;gBAC1B,oBAAoB,EAAE,EAAE;aACzB;YACD,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,gBAAgB,EAAE,EAAE;YACpB,YAAY,EAAE,KAAK;YACnB,aAAa,EAAE,IAAI;YACnB,oBAAoB,EAAE,IAAI,CAAC,gCAAgC,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;SACrF,CAAA;QAED,IAAI,CAAC,uCAAuC,EAAE,CAAC;QAE/C,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAEnD,IAAI,CAAC,4BAA4B,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE;YAC7E,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;QAChC,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,uCAAuC;QACrC,IAAI,IAAI,CAAC,4BAA4B,EAAE,CAAC;YACtC,IAAI,CAAC,4BAA4B,CAAC,WAAW,EAAE,CAAC;YAChD,IAAI,CAAC,4BAA4B,GAAG,IAAI,CAAC;QAC3C,CAAC;IACH,CAAC;IAEO,wBAAwB,CAAC,KAA0B;QACzD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,8BAA8B,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC;IACrJ,CAAC;IAED,gCAAgC,CAAC,SAAiB;QAChD,OAAO,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;IAC5E,CAAC;IAED,MAAM;QACJ,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;YAC9D,IAAI,EAAE;gBACJ,KAAK,EAAE,6BAA6B;gBACpC,IAAI,EAAE,2BAA2B;gBACjC,cAAc,EAAE,QAAQ;gBACxB,aAAa,EAAE,IAAI;aACpB;SACF,CAAC,CAAC;QAEH,SAAS,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YACzC,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;gBACrB,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACpC,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,0BAA0B;QAExB,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,cAAc,EACtC,IAAI,CAAC,aAAa,CAAC,sBAAsB,CAAC,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC,CAAC;YAClM,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,+BAA+B,EACvD,IAAI,WAAW,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,cAAc,CAAC,6BAA6B,EAAE,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAE,CAAC;YAClK,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,gBAAgB,EACxC,IAAI,SAAS,CACX,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,8BAA8B,CAAC,EAAE,EAAE,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,oBAAoB,EAAE,IAAI,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC,CAClP,CAAC,CAAC;YACL,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;QAChC,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;QACjC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IAED,MAAM;QACJ,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YAC1B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;YAClC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACjC,MAAM,KAAK,GAAiC;YAC1C,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE;SAChC,CAAC;QAEF,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,mBAAmB,CAAC,WAAyC,EAAE,SAAiB,IAAI;QAElF,IAAI,CAAC,4BAA4B,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,CAAC;aAC/G,SAAS,CAAC;YACT,IAAI,EAAE,aAAa,CAAC,EAAE;gBACpB,IAAI,CAAC,0BAA0B,CAAC,aAAa,CAAC,CAAC;gBAE/C,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC,CAAC;gBACzG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YAC5B,CAAC;YACD,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;gBAEf,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,kBAAkB,EAAE,CAAC;oBAC9G,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE;wBACxD,KAAK,EAAE,OAAO;qBACf,CAAC,CAAC;oBACH,SAAS,CAAC,WAAW,EAAE;yBACpB,SAAS,CAAC,MAAM,CAAC,EAAE;wBAClB,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;4BACxD,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;wBACvD,CAAC;oBACH,CAAC,CAAC,CAAC;oBACL,OAAO;gBACT,CAAC;gBAED,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,oBAAoB,EAAE,CAAC;oBACpI,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;wBAC9D,KAAK,EAAE,OAAO;wBACd,IAAI,EAAE;4BACJ,KAAK,EAAE,2BAA2B;4BAClC,IAAI,EAAE,2JAA2J;4BACjK,cAAc,EAAE,QAAQ;4BACxB,YAAY,EAAE,IAAI;yBACnB;qBACF,CAAC,CAAC;oBACH,SAAS,CAAC,WAAW,EAAE;yBACpB,SAAS,CAAC,GAAG,EAAE;wBACd,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC7B,CAAC,CAAC,CAAC;oBACL,OAAO;gBACT,CAAC;gBAED,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,+BAA+B,CAAC,EAAE,CAAC;oBAC1G,MAAM,YAAY,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,+BAA+B,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBAC1F,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;wBAC5C,KAAK,EAAE,OAAO;wBACd,IAAI,EAAE;4BACJ,KAAK,EAAE,4BAA4B;4BACnC,IAAI,EAAE,sEAAsE,GAAG,YAAY,GAAG,iGAAiG;4BAC/L,cAAc,EAAE,cAAc;4BAC9B,YAAY,EAAE,IAAI;yBACnB;qBACF,CAAC,CAAC;oBACH,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,CAAC,CAAC;gBAC3E,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC;gBAC/B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;gBAChC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACzB,CAAC;SACF,CAAC,CAAC;IACP,CAAC;IAED,wBAAwB,CAAC,OAAO;QAC9B,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YACzB,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;gBAC9D,IAAI,EAAE;oBACJ,KAAK,EAAE,kBAAkB;oBACzB,IAAI,EAAE,uFAAuF;oBAC7F,cAAc,EAAE,iBAAiB;oBACjC,aAAa,EAAE,IAAI;iBACpB;aACF,CAAC,CAAC;YAEH,SAAS,CAAC,WAAW,EAAE;iBACpB,SAAS,CAAC,MAAM,CAAC,EAAE;gBAClB,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;oBACrB,IAAI,CAAC,0BAA0B,EAAE,CAAC;oBAClC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;gBACtC,CAAC;YACH,CAAC,CAAC,CAAC;QACP,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAEO,qBAAqB,CAAC,OAAO;QACnC,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAqB,EAAE,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;IACtK,CAAC;IAED,8BAA8B;QAC5B,uEAAuE;IACzE,CAAC;IAED,2CAA2C;QACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;YAC5C,IAAI,EAAE;gBACJ,KAAK,EAAE,4CAA4C;gBACnD,IAAI,EAAE,6GAA6G;gBACnH,cAAc,EAAE,cAAc;aAC/B;SACF,CAAC,CAAC;IACL,CAAC;IAED,YAAY,CAAC,KAAa;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,mBAAmB;QACjB,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC;QACzC,IAAI,CAAC,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,2BAA2B,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;aACzH,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA,CAAC,CAAC,CAAC,CAAC;QAC7E,OAAO;IACT,CAAC;IAED,gBAAgB;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;QAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;QAE7B,KAAK,CAAC,oBAAoB,CAAC,mBAAmB,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM;YAC7F,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAEpC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YACnD,KAAK,CAAC,oBAAoB,CAAC,oBAAoB,GAAG,EAAE,CAAC;YACrD,KAAK,CAAC,oBAAoB,CAAC,qBAAqB,GAAG,KAAK,CAAC;QAC3D,CAAC;aAAM,CAAC;YACN,MAAM,WAAW,GAAG,KAAK,CAAC,oBAAoB,CAAC,qBAAqB,GAAG,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;mBACnH,IAAI,CAAC,aAAa,CAAC,6BAA6B,CAAC,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YACjJ,KAAK,CAAC,oBAAoB,CAAC,oBAAoB,GAAG,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE;gBAC9G,MAAM,UAAU,GAAG,CAAC,KAAK,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;gBAC3E,MAAM,YAAY,GAAG,CAAC,KAAK,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;gBAC7E,OAAO;oBACL,kBAAkB,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC;oBACjF,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC;oBACrE,oBAAoB,EAAE,IAAI,CAAC,aAAa,CAAC,6BAA6B,CAAC,IAAI,CAAC;wBAC1E,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,IAAI,CAAC,UAAU,IAAI,CAAC,WAAW,IAAI,YAAY,CAAC,CAAC,CAAC;iBAClF,CAAA;YACH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,qBAAqB,CAAC,KAAwC;QAC5D,OAAO,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;YACxD,IAAI,CAAC,aAAa,CAAC,6BAA6B,CAAC,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/F,CAAC;IAED,eAAe,CAAC,aAAsB;QACpC,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,aAAa,CAAC;QAC7C,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;8GAhVU,wBAAwB;kGAAxB,wBAAwB,+kBCrBrC,wpFAsCM;;2FDjBO,wBAAwB;kBALpC,SAAS;+BACE,6BAA6B;mKAM9B,SAAS;sBAAjB,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBAEG,gBAAgB;sBAAxB,KAAK;gBACG,iBAAiB;sBAAzB,KAAK;gBACG,mBAAmB;sBAA3B,KAAK;gBAEI,sBAAsB;sBAA/B,MAAM;gBAEG,aAAa;sBAAtB,MAAM;gBACG,UAAU;sBAAnB,MAAM;gBACG,aAAa;sBAAtB,MAAM;gBACG,UAAU;sBAAnB,MAAM;gBACG,oBAAoB;sBAA7B,MAAM;gBACG,iBAAiB;sBAA1B,MAAM","sourcesContent":["import { Component, OnInit, Input, Output, EventEmitter, OnDestroy } from '@angular/core';\nimport { BaseComponent } from '../base/base.component';\nimport { SegmentListModel, SettingDataModel, SettingFormulaModel, UpdateEvaluationFormulaModel } from 'ng-configcat-publicapi';\nimport { IFlagState } from '../_models/flag-state';\nimport { FormArray, FormControl, FormGroup, Validators } from '@angular/forms';\nimport { IPrerequisiteSetting, TargetingRuleForm, UpdateSettingValueForm } from '../_models/setting-value-formgroup';\nimport { PublicApiService } from '../_services';\nimport { Subscription, forkJoin, throwError } from 'rxjs';\nimport { ConfirmationDialogComponent } from '../dialogs/confirmation-dialog/confirmation-dialog';\nimport { ReasonDialogComponent } from '../dialogs/reason-dialog/reason-dialog.component';\nimport { FormGenerator } from '../_services/form-generator';\nimport { MatDialog } from '@angular/material/dialog';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { SaveSnackbarComponent } from '../dialogs/save-snackbar/save-snackbar.component';\nimport { DeleteSettingModel } from '../_models';\n\n@Component({\n  selector: 'configcat-feature-flag-item',\n  templateUrl: './feature-flag-item.component.html',\n  styleUrls: ['./feature-flag-item.component.scss']\n})\nexport class FeatureFlagItemComponent extends BaseComponent implements OnInit, OnDestroy {\n\n  @Input() productId!: string;\n  @Input() environmentId!: string;\n  @Input() configId!: string;\n  @Input() settingId!: number;\n\n  @Input() canDeleteSetting = true;\n  @Input() deleteSettingText = 'Delete setting';\n  @Input() showEnvironmentName = true;\n\n  @Output() deleteSettingRequested = new EventEmitter();\n\n  @Output() loadSucceeded = new EventEmitter();\n  @Output() loadFailed = new EventEmitter();\n  @Output() saveSucceeded = new EventEmitter();\n  @Output() saveFailed = new EventEmitter();\n  @Output() expandedStateChanged = new EventEmitter();\n  @Output() formValuesChanged = new EventEmitter();\n\n  segments!: SegmentListModel[];\n  dashboardBasePath: string;\n  loading = true;\n\n  formGroup: FormGroup<UpdateSettingValueForm>;\n  formValueChangesSubscription: Subscription;\n\n  settings: SettingDataModel[];\n\n  flagState: IFlagState;\n\n  settingFormula: SettingFormulaModel;\n  prerequisiteSettings: IPrerequisiteSetting[];\n\n  showFeedBackMessage = false;\n\n  hasSettingValues = false;\n\n  hasOtherEnvironment = false;\n\n  constructor(\n    private formGenerator: FormGenerator,\n    private dialog: MatDialog,\n    private snackBar: MatSnackBar,\n    publicApiService: PublicApiService\n  ) {\n    super(publicApiService);\n  }\n\n  ngOnInit() {\n    this.reloadSettingValues();\n  }\n\n  ngOnDestroy(): void {\n    this.unsubscribeFormValueChangesSubscription();\n  }\n\n  reloadSettingValues() {\n\n    this.loading = true;\n    this.createSettingValuesV2Service()\n\n    forkJoin({\n      segments: this.createSegmentsService().getSegments(this.productId),\n      settings: this.createSettingsService().getSettings(this.configId),\n      settingFormula: this.createSettingValuesV2Service().getSettingValueV2(this.environmentId, this.settingId)\n    }).subscribe(result => {\n      this.settings = result.settings;\n      this.prerequisiteSettings = this.settings.map(sv => {\n        return {\n          settingId: sv.settingId,\n          key: sv.key,\n          name: sv.name,\n          settingType: sv.settingType\n        }\n      });\n      this.segments = result.segments;\n      this.handleFetchedSettingValues(result.settingFormula);\n      this.loading = false;\n      this.loadSucceeded.emit();\n    },\n      (error) => {\n        this.loadFailed.emit(error);\n        return throwError(error);\n      });\n  }\n\n  handleFetchedSettingValues(model: SettingFormulaModel) {\n    this.settingFormula = model;\n    // when we have less we had previously\n    this.flagState = {\n      addButtonRenderState: {\n        hasPercentageOnlyRule: false,\n        renderTopAddButtons: false,\n        addRuleButtonTracker: []\n      },\n      readOnly: model.readOnly,\n      dependeeSettings: [],\n      settingValue: model,\n      panelExpanded: true,\n      prerequisiteSettings: this.getAvailablePrerequisiteSettings(model.setting.settingId)\n    }\n\n    this.unsubscribeFormValueChangesSubscription();\n\n    this.createFormGroupFromState(this.settingFormula);\n\n    this.formValueChangesSubscription = this.formGroup.valueChanges.subscribe(() => {\n      this.formValuesChanged.emit();\n    })\n\n    this.recalcAddButtons();\n    this.recalcPrerequisites();\n  }\n\n  unsubscribeFormValueChangesSubscription() {\n    if (this.formValueChangesSubscription) {\n      this.formValueChangesSubscription.unsubscribe();\n      this.formValueChangesSubscription = null;\n    }\n  }\n\n  private createFormGroupFromState(model: SettingFormulaModel) {\n    this.formGroup = this.formGenerator.generateSettingValuesFormGroup(model, model.readOnly, this.prerequisiteSettings, model.featureFlagLimitations);\n  }\n\n  getAvailablePrerequisiteSettings(settingId: number) {\n    return this.prerequisiteSettings.filter(ds => ds.settingId !== settingId);\n  }\n\n  revert() {\n    const dialogRef = this.dialog.open(ConfirmationDialogComponent, {\n      data: {\n        title: 'Revert to last saved state?',\n        body: 'All changes will be lost.',\n        yesButtonLabel: 'Revert',\n        noButtonLabel: 'No'\n      }\n    });\n\n    dialogRef.afterClosed().subscribe(result => {\n      if (result === 'yes') {\n        this.revertDirtyValuesFromState();\n      }\n    });\n  }\n\n  revertDirtyValuesFromState() {\n\n    if (this.formGroup.dirty) {\n      this.formGroup.setControl('defaultValue',\n        this.formGenerator.generateValueFormGroup(this.settingFormula.defaultValue, this.settingFormula.setting.settingType, this.settingFormula.readOnly, this.settingFormula.featureFlagLimitations));\n      this.formGroup.setControl('percentageEvaluationAttribute',\n        new FormControl({ value: this.settingFormula.percentageEvaluationAttribute, disabled: this.settingFormula.readOnly }, { validators: [Validators.max(1000)] }),);\n      this.formGroup.setControl('targetingRules',\n        new FormArray<FormGroup<TargetingRuleForm>>(\n          this.settingFormula.targetingRules.map(ft => this.formGenerator.generateTargetingRuleFormGroup(ft, this.settingFormula.setting.settingType, this.settingFormula.readOnly, this.prerequisiteSettings, this.settingFormula.featureFlagLimitations))\n        ));\n      this.recalcAddButtons();\n    }\n\n    this.formGroup.markAsPristine();\n    this.formGroup.markAsUntouched();\n    this.recalcPrerequisites();\n    this.showFeedBackMessage = false;\n  }\n\n  submit() {\n    if (!this.formGroup) {\n      return;\n    }\n\n    if (!this.formGroup.valid) {\n      this.showFeedBackMessage = true;\n      this.formGroup.markAllAsTouched();\n      return;\n    }\n\n    this.showFeedBackMessage = false;\n    const value: UpdateEvaluationFormulaModel = {\n      ...this.formGroup.getRawValue(),\n    };\n\n    this.updateSettingValues(value);\n  }\n\n  updateSettingValues(updateModel: UpdateEvaluationFormulaModel, reason: string = null) {\n\n    this.createSettingValuesV2Service().replaceSettingValueV2(this.environmentId, this.settingId, updateModel, reason)\n      .subscribe({\n        next: settingValues => {\n          this.handleFetchedSettingValues(settingValues);\n\n          this.snackBar.openFromComponent(SaveSnackbarComponent, { duration: 5000, panelClass: 'green-snackbar' });\n          this.saveSucceeded.emit();\n        },\n        error: (error) => {\n\n          if (error.status === 400 && error.error && error.error.Reason && error.error.Reason[0] === 'Reason required.') {\n            const dialogRef = this.dialog.open(ReasonDialogComponent, {\n              width: '450px'\n            });\n            dialogRef.afterClosed()\n              .subscribe(result => {\n                if (result && result.button === 'save' && result.reason) {\n                  this.updateSettingValues(updateModel, result.reason);\n                }\n              });\n            return;\n          }\n\n          if (error.status === 400 && error.error && error.error.SegmentCondition && error.error.SegmentCondition[0] === 'Segment not found.') {\n            const dialogRef = this.dialog.open(ConfirmationDialogComponent, {\n              width: '450px',\n              data: {\n                title: 'Cannot save feature flags',\n                body: 'A segment referenced by one of your feature flags has been deleted. Reload the config to see its latest state, apply your changes and try the save again.',\n                yesButtonLabel: 'Reload',\n                hideNoButton: true\n              }\n            });\n            dialogRef.afterClosed()\n              .subscribe(() => {\n                this.reloadSettingValues();\n              });\n            return;\n          }\n\n          if (error.status === 400 && error.error && ('' + error.error).startsWith('Circular dependency detected.')) {\n            const errorMessage = ('' + error.error).slice('Circular dependency detected.'.length + 1);\n            this.dialog.open(ConfirmationDialogComponent, {\n              width: '450px',\n              data: {\n                title: 'Cannot save feature flags.',\n                body: 'Circular dependency detected between the following feature flags:<p>' + errorMessage + '</p>Please <strong>eliminate the circular dependency</strong> before saving your feature flags.',\n                yesButtonLabel: 'I understand',\n                hideNoButton: true\n              }\n            });\n            return;\n          }\n\n          this.formGroup.setErrors({ internalServerError: 'Internal server error' });\n          this.formGroup.markAsTouched();\n          this.showFeedBackMessage = true;\n          this.saveFailed.emit();\n        }\n      });\n  }\n\n  onDeleteSettingRequested(setting) {\n    if (this.formGroup.dirty) {\n      const dialogRef = this.dialog.open(ConfirmationDialogComponent, {\n        data: {\n          title: 'Discard changes?',\n          body: 'You have unsaved feature flag changes. If you continue, unsaved changes will be lost.',\n          yesButtonLabel: 'Discard changes',\n          noButtonLabel: 'No'\n        }\n      });\n\n      dialogRef.afterClosed()\n        .subscribe(result => {\n          if (result === 'yes') {\n            this.revertDirtyValuesFromState();\n            this.deleteSettingInternal(setting);\n          }\n        });\n    } else {\n      this.deleteSettingInternal(setting);\n    }\n  }\n\n  private deleteSettingInternal(setting) {\n    this.deleteSettingRequested.emit(<DeleteSettingModel>{ config: this.settingFormula.config, environment: this.settingFormula.environment, setting: setting.setting })\n  }\n\n  subscriptionLimitReachedCalled() {\n    // TODO this.subscriptionLimitReached(this.constellation, this.dialog);\n  }\n\n  addSegmentConditionRequestedWithoutSegments() {\n    this.dialog.open(ConfirmationDialogComponent, {\n      data: {\n        title: 'There are no segments in this product yet.',\n        body: `Go ahead to the ConfiCat Dashboard and create your first user segment before adding it to a targeting rule.`,\n        yesButtonLabel: `I understand`\n      }\n    });\n  }\n\n  trackByIndex(index: number): any {\n    return index;\n  }\n\n  recalcPrerequisites(): void {\n    const settingValue = this.settingFormula;\n    this.flagState.dependeeSettings = this.settings.filter(s => settingValue.settingIdsWherePrerequisite?.includes(s.settingId))\n      .map(s => { return { key: s.key, name: s.name, settingId: s.settingId } });\n    return;\n  }\n\n  recalcAddButtons(): void {\n    const state = this.flagState;\n    const group = this.formGroup;\n\n    state.addButtonRenderState.renderTopAddButtons = !group.controls.targetingRules.controls.length ||\n      this.hasOnlyPercentageRule(group);\n\n    if (!group.controls.targetingRules.controls.length) {\n      state.addButtonRenderState.addRuleButtonTracker = [];\n      state.addButtonRenderState.hasPercentageOnlyRule = false;\n    } else {\n      const hasPercOnly = state.addButtonRenderState.hasPercentageOnlyRule = group.controls.targetingRules.controls.length > 0\n        && this.formGenerator.isPercentageOnlyTargetingRule(group.controls.targetingRules.controls[group.controls.targetingRules.controls.length - 1]);\n      state.addButtonRenderState.addRuleButtonTracker = group.controls.targetingRules.controls.map((item, i, rules) => {\n        const isLastRule = i === group.controls.targetingRules.controls.length - 1;\n        const isBeforeLast = i === group.controls.targetingRules.controls.length - 2;\n        return {\n          showAddRuleButtons: hasPercOnly ? i === rules.length - 2 : i === rules.length - 1,\n          showOrChip: hasPercOnly ? i < rules.length - 2 : i < rules.length - 1,\n          renderSeparationArea: this.formGenerator.isPercentageOnlyTargetingRule(item) ||\n            (this.settingFormula.readOnly && (isLastRule || (hasPercOnly && isBeforeLast))),\n        }\n      });\n    }\n  }\n\n  hasOnlyPercentageRule(group: FormGroup<UpdateSettingValueForm>): boolean {\n    return group.controls.targetingRules.controls.length === 1 &&\n      this.formGenerator.isPercentageOnlyTargetingRule(group.controls.targetingRules.controls[0])\n  }\n\n  expandedChanged(expandedState: boolean): void {\n    this.flagState.panelExpanded = expandedState;\n    this.expandedStateChanged.emit();\n  }\n}\n","<div class=\"container\">\n    <ng-container *ngIf=\"!loading\">\n        <form [formGroup]=\"formGroup\" (ngSubmit)=\"submit()\" id=\"feature-flag-form\">\n            <div [ngClass]=\"{'invalid-flag': formGroup.invalid}\">\n                <app-feature-flag [formGroup]=\"formGroup\" [flagState]=\"flagState\" [segments]=\"segments\"\n                    (deleteSettingRequested)=\"onDeleteSettingRequested($event)\"\n                    [featureFlagLimitations]=\"settingFormula.featureFlagLimitations\" [hasOtherEnvironment]=\"false\"\n                    (subscriptionLimitReached)=\"subscriptionLimitReachedCalled()\"\n                    (addSegmentConditionRequestedWithoutSegments)=\"addSegmentConditionRequestedWithoutSegments()\"\n                    (prerequisiteConditionChanged)=\"recalcPrerequisites()\" (recalcAddButtons)=\"recalcAddButtons()\"\n                    (expandedChanged)=\"expandedChanged($event)\"\n                    [showEnvironmentName]=\"showEnvironmentName\" [environmentName]=\"settingFormula.environment.name\"\n                    [deleteSettingText]=\"deleteSettingText\">\n                </app-feature-flag>\n            </div>\n            <div class=\"save\" *ngIf=\"!settingFormula.readOnly && formGroup?.dirty\">\n                <button class=\"save-button\" mat-flat-button color=\"warn\" type=\"submit\" [class.animate]=\"formGroup.dirty\"\n                    [track]=\"['save & publish click', 'feature flags and settings']\">\n                    <mat-icon>backup</mat-icon> <span> Save & publish changes</span>\n                </button>\n                <button type=\"button\" class=\"revert-button\" mat-stroked-button (click)=\"revert()\"\n                    [track]=\"['revert click', 'feature flags and settings']\">\n                    <span>Revert</span>\n                </button>\n                <div class=\"feedback\" *ngIf=\"formGroup.touched && formGroup.invalid && showFeedBackMessage\">\n                    <div class=\"error\" *ngIf=\"formGroup.errors && formGroup.errors.internalServerError\">\n                        <span>Something went wrong and we could not save your settings. You can try again or <a\n                                href=\"https://configcat.com/support\" target=\"_blank\" rel=\"noopener noreferrer\">contact\n                                us.</a></span>\n                    </div>\n                    <div class=\"error\" *ngIf=\"!formGroup.errors || !formGroup.errors.internalServerError\">\n                        <span>Oh no! A feature flag has invalid or missing data.&nbsp;</span>\n                    </div>\n                </div>\n            </div>\n        </form>\n\n    </ng-container>\n</div>"]}

package/{esm2020 → esm2022}/public-api.mjs

@@ -11,4 +11,5 @@ export * from './lib/selects/config-select/config-select.component';
 export * from './lib/selects/environment-select/environment-select.component';
 export * from './lib/selects/setting-select/setting-select.component';
 export * from './lib/dialogs/delete-setting-dialog/delete-setting-dialog.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25nLWNvbmZpZ2NhdC1wdWJsaWNhcGktdWkvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMsK0RBQStELENBQUM7QUFDOUUsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLHFFQUFxRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZy1jb25maWdjYXQtcHVibGljYXBpLXVpXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmctY29uZmlnY2F0LXB1YmxpY2FwaS11aS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvX2RpcmVjdGl2ZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvX3NlcnZpY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NldHRpbmctaXRlbS9zZXR0aW5nLWl0ZW0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGhvcml6YXRpb24vYXV0aG9yaXphdGlvbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VsZWN0cy9wcm9kdWN0LXNlbGVjdC9wcm9kdWN0LXNlbGVjdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VsZWN0cy9jb25maWctc2VsZWN0L2NvbmZpZy1zZWxlY3QuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlbGVjdHMvZW52aXJvbm1lbnQtc2VsZWN0L2Vudmlyb25tZW50LXNlbGVjdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VsZWN0cy9zZXR0aW5nLXNlbGVjdC9zZXR0aW5nLXNlbGVjdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlhbG9ncy9kZWxldGUtc2V0dGluZy1kaWFsb2cvZGVsZXRlLXNldHRpbmctZGlhbG9nLmNvbXBvbmVudCc7XG4iXX0=
+export * from './lib/v2/feature-flag-item.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25nLWNvbmZpZ2NhdC1wdWJsaWNhcGktdWkvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMsK0RBQStELENBQUM7QUFDOUUsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLHFFQUFxRSxDQUFDO0FBQ3BGLGNBQWMsc0NBQXNDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5nLWNvbmZpZ2NhdC1wdWJsaWNhcGktdWlcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9uZy1jb25maWdjYXQtcHVibGljYXBpLXVpLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9fZGlyZWN0aXZlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9fc2VydmljZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2V0dGluZy1pdGVtL3NldHRpbmctaXRlbS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXV0aG9yaXphdGlvbi9hdXRob3JpemF0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZWxlY3RzL3Byb2R1Y3Qtc2VsZWN0L3Byb2R1Y3Qtc2VsZWN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZWxlY3RzL2NvbmZpZy1zZWxlY3QvY29uZmlnLXNlbGVjdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VsZWN0cy9lbnZpcm9ubWVudC1zZWxlY3QvZW52aXJvbm1lbnQtc2VsZWN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZWxlY3RzL3NldHRpbmctc2VsZWN0L3NldHRpbmctc2VsZWN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaWFsb2dzL2RlbGV0ZS1zZXR0aW5nLWRpYWxvZy9kZWxldGUtc2V0dGluZy1kaWFsb2cuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3YyL2ZlYXR1cmUtZmxhZy1pdGVtLmNvbXBvbmVudCc7Il19