ng-configcat-publicapi-ui 3.0.7 → 3.1.0

package/esm2022/lib/_directives/input-display-normalizer.directive.mjs

@@ -0,0 +1,38 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Makes sure that values entered into HTML input fields are displayed in the correct format,
+ * where correct means normalized (e.g. `'.10'` --> `'0.1'`) and corresponding to the locale setting.
+ *
+ * The format is adjusted on the blur event. Only the format of number inputs is adjusted currently.
+ */
+export class InputDisplayNormalizerDirective {
+    constructor() { }
+    onChange($event) {
+        const target = $event.target;
+        if (target.type === 'number') {
+            let value = target.value;
+            value = value.trim() !== '' ? Number(value) : NaN;
+            if (isFinite(value)) {
+                // The string returned by the `value` property and the string displayed in the input field are not necessarily equal.
+                // HACK: When the returned and the displayed value differs only in the decimal separator,
+                // Chrome won't update the displayed value unless the value is changed first...
+                target.value = '';
+                target.value = value;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InputDisplayNormalizerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: InputDisplayNormalizerDirective, selector: "input[inputDisplayNormalizer]", host: { listeners: { "blur": "onChange($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: InputDisplayNormalizerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'input[inputDisplayNormalizer]'
+                }]
+        }], ctorParameters: () => [], propDecorators: { onChange: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/_services/form-helper.mjs

@@ -0,0 +1,104 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { PlatformHelper } from './platform-helper';
+export class FormHelper {
+    static getErrorMessage(control, hint = '') {
+        if (!control || control.valid) {
+            return;
+        }
+        if (control.hasError('required')) {
+            return `${hint} The field is required.`;
+        }
+        if (control.hasError('pattern')) {
+            return 'Not a valid e-mail address.';
+        }
+        if (control.hasError('minlength')) {
+            return 'The field must be at least ' + control.getError('minlength').requiredLength + ' characters long';
+        }
+        if (control.hasError('maxlength')) {
+            return 'The field must be at max ' + control.getError('maxlength').requiredLength + ' characters long';
+        }
+        return;
+    }
+    static handleErrors(formGroup, error) {
+        if (error instanceof HttpErrorResponse) {
+            const response = error;
+            switch (response.status) {
+                case 400:
+                    let unknownFieldName = false;
+                    for (const fieldName in error.error) {
+                        if (error.error.hasOwnProperty(fieldName) && error.error[fieldName] &&
+                            (error.error[fieldName]?.length > 0 || error.error[fieldName]?.Errors?.length > 0)) {
+                            let jsonFieldName = fieldName;
+                            if (jsonFieldName.length > 0) {
+                                jsonFieldName = jsonFieldName[0].toLowerCase() + jsonFieldName.slice(1);
+                            }
+                            const errorMessage = error.error[fieldName]?.Errors?.length > 0 ?
+                                (error.error[fieldName]?.Errors.map((e) => e.ErrorMessage)).join(', ')
+                                : error.error[fieldName];
+                            if (formGroup.controls.hasOwnProperty(jsonFieldName)) {
+                                formGroup.controls[jsonFieldName].setErrors({ serverSide: errorMessage });
+                            }
+                            else {
+                                unknownFieldName = true;
+                            }
+                        }
+                    }
+                    if (unknownFieldName) {
+                        formGroup.setErrors({ serverSide: 'Something went wrong.' });
+                    }
+                    break;
+                // in these cases we do not show errors on the form, they're handled by the http
+                // interceptor in src\app\_interceptors\httpstatuscode.interceptor.ts
+                case 402:
+                case 429:
+                    return;
+            }
+        }
+        else {
+            formGroup.setErrors({ serverSide: 'Something went wrong on our side. This is not your fault. Please try again.' });
+        }
+    }
+    /**
+     * Converts a value representing a number to a `number` value.
+     * Returns `NaN` in the case of non-numerical values.
+     */
+    static normalizeNumber(value) {
+        switch (typeof value) {
+            case "number":
+                return value;
+            case "string":
+                // NOTE: `Number()` converts whitespace strings to 0.
+                return value.trim() === '' ? NaN : Number(value);
+            case "bigint":
+                return Number(value);
+            default:
+                return NaN;
+        }
+    }
+    /**
+     * Converts a value representing a number to the normalized `string`
+     * representation of the number. (e.g. `.1` --> `'0.1'`, `3.14e2` --> `'314'`).
+     * Returns `''` in the case of non-numerical values or non-finite numerical values.
+     */
+    static normalizeNumberStoredAsString(value) {
+        value = FormHelper.normalizeNumber(value);
+        // NOTE: `NaN` is not considered finite.
+        return isFinite(value) ? value + '' : '';
+    }
+    static formatNumberForDisplay(value) {
+        if (!isFinite(value)) {
+            return '';
+        }
+        // Chromium-based browsers don't respect the `lang` attribute,
+        // they use a display format corresponding to the browser's language setting.
+        if (PlatformHelper.isChromium()) {
+            return value.toLocaleString();
+        }
+        // Firefox (and probably other browsers) respect the `lang` attribute,
+        // which is currently set to the fixed value of "en" (see index.html),
+        // so in these cases dot should be used as the decimal separator.
+        // (In case localization is implemented in the application, this logic should be revised!)
+        return value + '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-helper.js","sourceRoot":"","sources":["../../../../../projects/ng-configcat-publicapi-ui/src/lib/_services/form-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\nimport { AbstractControl, FormGroup } from '@angular/forms';\nimport { PlatformHelper } from './platform-helper';\n\nexport class FormHelper {\n\n    public static getErrorMessage(control: AbstractControl, hint: string = '') {\n        if (!control || control.valid) {\n            return;\n        }\n\n        if (control.hasError('required')) {\n            return `${hint} The field is required.`;\n        }\n\n        if (control.hasError('pattern')) {\n            return 'Not a valid e-mail address.';\n        }\n\n        if (control.hasError('minlength')) {\n            return 'The field must be at least ' + control.getError('minlength').requiredLength + ' characters long';\n        }\n\n        if (control.hasError('maxlength')) {\n            return 'The field must be at max ' + control.getError('maxlength').requiredLength + ' characters long';\n        }\n\n        return;\n    }\n\n\n    public static handleErrors(formGroup: FormGroup, error: any) {\n        if (error instanceof HttpErrorResponse) {\n            const response = error as HttpErrorResponse;\n            switch (response.status) {\n                case 400:\n                    let unknownFieldName = false;\n                    for (const fieldName in error.error) {\n                        if (error.error.hasOwnProperty(fieldName) && error.error[fieldName] &&\n                            (error.error[fieldName]?.length > 0 || error.error[fieldName]?.Errors?.length > 0)) {\n                            let jsonFieldName = fieldName;\n                            if (jsonFieldName.length > 0) {\n                                jsonFieldName = jsonFieldName[0].toLowerCase() + jsonFieldName.slice(1);\n                            }\n\n                            const errorMessage = error.error[fieldName]?.Errors?.length > 0 ?\n                                (error.error[fieldName]?.Errors.map((e: any) => e.ErrorMessage)).join(', ')\n                                : error.error[fieldName];\n\n                            if (formGroup.controls.hasOwnProperty(jsonFieldName)) {\n                                formGroup.controls[jsonFieldName].setErrors({ serverSide: errorMessage });\n                            } else {\n                                unknownFieldName = true;\n                            }\n                        }\n                    }\n                    if (unknownFieldName) {\n                        formGroup.setErrors({ serverSide: 'Something went wrong.' });\n                    }\n                    break;\n                // in these cases we do not show errors on the form, they're handled by the http\n                // interceptor in src\\app\\_interceptors\\httpstatuscode.interceptor.ts\n                case 402:\n                case 429:\n                    return;\n            }\n        } else {\n            formGroup.setErrors({ serverSide: 'Something went wrong on our side. This is not your fault. Please try again.' });\n        }\n    }\n\n    /**\n     * Converts a value representing a number to a `number` value.\n     * Returns `NaN` in the case of non-numerical values.\n     */\n    public static normalizeNumber(value: any): number {\n        switch (typeof value) {\n            case \"number\":\n                return value;\n            case \"string\":\n                // NOTE: `Number()` converts whitespace strings to 0.\n                return value.trim() === '' ? NaN : Number(value);\n            case \"bigint\":\n                return Number(value);\n            default:\n                return NaN;\n        }\n    }\n\n    /**\n     * Converts a value representing a number to the normalized `string`\n     * representation of the number. (e.g. `.1` --> `'0.1'`, `3.14e2` --> `'314'`).\n     * Returns `''` in the case of non-numerical values or non-finite numerical values.\n     */\n    public static normalizeNumberStoredAsString(value: any): string {\n        value = FormHelper.normalizeNumber(value);\n        // NOTE: `NaN` is not considered finite.\n        return isFinite(value) ? value + '' : '';\n    }\n\n    \n  public static formatNumberForDisplay(value: number) {\n    if (!isFinite(value)) {\n      return '';\n    }\n\n    // Chromium-based browsers don't respect the `lang` attribute,\n    // they use a display format corresponding to the browser's language setting.\n    if (PlatformHelper.isChromium()) {\n      return value.toLocaleString();\n    }\n\n    // Firefox (and probably other browsers) respect the `lang` attribute,\n    // which is currently set to the fixed value of \"en\" (see index.html),\n    // so in these cases dot should be used as the decimal separator.\n    // (In case localization is implemented in the application, this logic should be revised!)\n    return value + '';\n  }\n}\n"]}

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

@@ -59,13 +59,13 @@ export class PublicApiService {
     getDashboardBasePath() {
         return this.configuration?.dashboardBasePath ?? 'https://app.configcat.com';
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PublicApiService, deps: [{ token: i1.HttpClient }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PublicApiService, providedIn: 'root' }); }
 }
-PublicApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PublicApiService, deps: [{ token: i1.HttpClient }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-PublicApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PublicApiService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PublicApiService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: PublicApiService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.Configuration, decorators: [{
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.Configuration, decorators: [{
                     type: Optional
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.service.js","sourceRoot":"","sources":["../../../../../projects/ng-configcat-publicapi-ui/src/lib/_services/public-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport {\n    Configuration as PublicApiConfiguration,\n    ProductsService, EnvironmentsService, ConfigsService,\n    FeatureFlagsSettingsService, FeatureFlagSettingValuesService, MeService,\n    IntegrationLinksService,\n    SegmentsService\n} from 'ng-configcat-publicapi';\nimport { Configuration } from '../configuration';\n\n@Injectable({ providedIn: 'root' })\nexport class PublicApiService {\n\n    constructor(\n        private httpClient: HttpClient,\n        @Optional() private configuration: Configuration) {\n    }\n\n    createMeService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new MeService(this.httpClient, basePath ?? this.configuration?.basePath,\n            new PublicApiConfiguration({\n                username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n                password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n            }));\n    }\n\n    createProductsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new ProductsService(this.httpClient, basePath ?? this.configuration?.basePath,\n            new PublicApiConfiguration({\n                username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n                password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n            }));\n    }\n\n    createConfigsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new ConfigsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createEnvironmentsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new EnvironmentsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createSettingsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new FeatureFlagsSettingsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createSettingValuesService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new FeatureFlagSettingValuesService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createIntegrationLinksService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new IntegrationLinksService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createSegmentsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new SegmentsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    getDashboardBasePath() {\n        return this.configuration?.dashboardBasePath ?? 'https://app.configcat.com';\n    }\n}\n"]}
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.service.js","sourceRoot":"","sources":["../../../../../projects/ng-configcat-publicapi-ui/src/lib/_services/public-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport {\n    Configuration as PublicApiConfiguration,\n    ProductsService, EnvironmentsService, ConfigsService,\n    FeatureFlagsSettingsService, FeatureFlagSettingValuesService, MeService,\n    IntegrationLinksService,\n    SegmentsService\n} from 'ng-configcat-publicapi';\nimport { Configuration } from '../configuration';\n\n@Injectable({ providedIn: 'root' })\nexport class PublicApiService {\n\n    constructor(\n        private httpClient: HttpClient,\n        @Optional() private configuration: Configuration) {\n    }\n\n    createMeService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new MeService(this.httpClient, basePath ?? this.configuration?.basePath,\n            new PublicApiConfiguration({\n                username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n                password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n            }));\n    }\n\n    createProductsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new ProductsService(this.httpClient, basePath ?? this.configuration?.basePath,\n            new PublicApiConfiguration({\n                username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n                password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n            }));\n    }\n\n    createConfigsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new ConfigsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createEnvironmentsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new EnvironmentsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createSettingsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new FeatureFlagsSettingsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createSettingValuesService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new FeatureFlagSettingValuesService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createIntegrationLinksService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new IntegrationLinksService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    createSegmentsService(basicAuthUsername: string | null = null, basicAuthPassword: string | null = null, basePath: string | null = null) {\n        return new SegmentsService(this.httpClient, basePath ?? this.configuration?.basePath, new PublicApiConfiguration({\n            username: basicAuthUsername ?? this.configuration?.basicAuthUsername,\n            password: basicAuthPassword ?? this.configuration?.basicAuthPassword\n        }));\n    }\n\n    getDashboardBasePath() {\n        return this.configuration?.dashboardBasePath ?? 'https://app.configcat.com';\n    }\n}\n"]}

package/esm2022/lib/_services/setting-list-form-helper.mjs

@@ -0,0 +1,171 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { RolloutRuleComparator, SettingType } from 'ng-configcat-publicapi';
+import { FormHelper } from './form-helper';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class SettingListFormHelper {
+    constructor(formBuilder) {
+        this.formBuilder = formBuilder;
+    }
+    createSettingValuesFormGroup(settingValuesModel) {
+        const formGroup = this.formBuilder.group({
+            settingValues: this.formBuilder.array(settingValuesModel.settingValues.map(sv => {
+                return this.createSettingValueFormGroup(sv, settingValuesModel.readOnly);
+            })),
+            // Decorator
+            environment: this.formBuilder.group({
+                environmentId: [{ value: settingValuesModel.environment.environmentId, disabled: true }],
+                name: [{ value: settingValuesModel.environment.name, disabled: true }],
+            }),
+            comparisonAttributes: [[]]
+        });
+        const rolloutRules = this.getAllRolloutRules(formGroup);
+        const comparisonAttributes = this.getComparisonAttributes(rolloutRules);
+        formGroup.patchValue({ comparisonAttributes: comparisonAttributes });
+        return formGroup;
+    }
+    createSettingValueFormGroup(settingValueModel, readOnly) {
+        if (!settingValueModel.setting) {
+            return this.formBuilder.group({});
+        }
+        return this.formBuilder.group({
+            settingId: [settingValueModel.setting.settingId],
+            value: [
+                { value: settingValueModel.value, disabled: readOnly },
+                this.getValidatorsForSettingType(settingValueModel.setting.settingType)
+            ],
+            rolloutPercentageItems: settingValueModel.rolloutPercentageItems
+                ? this.formBuilder.array(settingValueModel.rolloutPercentageItems.map(p => {
+                    // @ts-ignore()
+                    return this.createRolloutPercentageItemFormGroup(p, readOnly, settingValueModel.setting.settingType);
+                }))
+                : this.formBuilder.array([]), rolloutRules: settingValueModel.rolloutRules
+                ? this.formBuilder.array(settingValueModel.rolloutRules.map(r => {
+                    // @ts-ignore()
+                    return this.createRolloutRuleFormGroup(r, readOnly, settingValueModel.setting.settingType);
+                }))
+                : this.formBuilder.array([]),
+            updatedAt: [{ value: settingValueModel.updatedAt, disabled: true }],
+            lastUpdaterUserEmail: [{ value: settingValueModel.lastUpdaterUserEmail, disabled: true }],
+            lastUpdaterUserFullName: [{ value: settingValueModel.lastUpdaterUserFullName, disabled: true }],
+            rolloutPercentageItemsSum: [{ value: 100, disabled: false }, [Validators.min(100), Validators.max(100)]],
+            // Decoration
+            setting: this.formBuilder.group({
+                settingId: [{ value: settingValueModel.setting.settingId, disabled: true }],
+                key: [{ value: settingValueModel.setting.key, disabled: true }],
+                name: [{ value: settingValueModel.setting.name, disabled: true }],
+                hint: [{ value: settingValueModel.setting.hint, disabled: true }],
+                settingType: [{ value: settingValueModel.setting.settingType, disabled: true }],
+                creatorEmail: [{ value: settingValueModel.setting.creatorEmail, disabled: true }],
+                creatorFullName: [{ value: settingValueModel.setting.creatorFullName, disabled: true }],
+                createdAt: [{ value: settingValueModel.setting.createdAt, disabled: true }]
+            }),
+            integrationLinks: settingValueModel.integrationLinks ? this.formBuilder.array(settingValueModel.integrationLinks.map(il => {
+                return this.formBuilder.group({
+                    key: [{ value: il.key, disabled: true }],
+                    description: [{ value: il.description, disabled: true }],
+                    integrationLinkType: [{ value: il.integrationLinkType, disabled: true }],
+                    url: [{ value: il.url, disabled: true }],
+                });
+            })) : this.formBuilder.array([])
+        });
+    }
+    createRolloutPercentageItemFormGroup(p, readOnly, settingType) {
+        return this.formBuilder.group({
+            percentage: [{ value: p.percentage, disabled: readOnly }, [Validators.required, Validators.min(0), Validators.max(100)]],
+            value: [
+                { value: p.value, disabled: readOnly },
+                this.getValidatorsForSettingType(settingType)
+            ],
+            valueDisabled: [
+                { value: p.value, disabled: true }, // For percentage item value
+            ]
+        });
+    }
+    createRolloutRuleFormGroup(r, readOnly, settingType) {
+        if (r.comparator) {
+            return this.formBuilder.group({
+                type: [{ value: 0, disabled: true }],
+                comparisonAttribute: [{ value: r.comparisonAttribute, disabled: readOnly }, [Validators.required]],
+                comparator: [{ value: r.comparator, disabled: readOnly }, [Validators.required]],
+                comparisonValue: [{ value: r.comparisonValue, disabled: readOnly }, [Validators.required]],
+                value: [
+                    { value: r.value, disabled: readOnly },
+                    this.getValidatorsForSettingType(settingType)
+                ],
+            });
+        }
+        else if (r.segmentComparator) {
+            return this.formBuilder.group({
+                type: [{ value: 1, disabled: true }],
+                segmentComparator: [{ value: r.segmentComparator, disabled: readOnly }, [Validators.required]],
+                segmentId: [{ value: r.segmentId, disabled: readOnly }, [Validators.required]],
+                value: [
+                    { value: r.value, disabled: readOnly },
+                    this.getValidatorsForSettingType(settingType)
+                ],
+            });
+        }
+        else {
+            throw new Error('Invalid rollout rule');
+        }
+    }
+    getValidatorsForSettingType(settingType) {
+        switch (settingType) {
+            case SettingType.Int:
+                return [Validators.required,
+                    Validators.min(-2147483648), Validators.max(2147483647), Validators.pattern('^[-+]?[0-9]\\d*$')];
+            case SettingType.Double:
+                return [Validators.required, Validators.min(-1.79769313486232E+308), Validators.max(1.79769313486232E+308)];
+            case SettingType.String:
+            case SettingType.Boolean:
+                return [Validators.required];
+            default:
+                return [];
+        }
+    }
+    getAllRolloutRules(formGroup) {
+        const settingValues = formGroup.get('settingValues');
+        const rolloutRules = settingValues.controls.map(cv => cv.get('rolloutRules').value);
+        return rolloutRules.length === 0 ? rolloutRules : rolloutRules.reduce((a, b) => a.concat(b));
+    }
+    getComparisonAttributes(rolloutRules) {
+        if (rolloutRules.length > 0) {
+            const currentComparisonAttributes = rolloutRules.map(r => r.comparisonAttribute);
+            const defaultComparisonAttributes = ['Identifier', 'Email', 'Country'];
+            const comparisonAttributes = currentComparisonAttributes.filter(c => defaultComparisonAttributes.indexOf(c) === -1);
+            return Array.from(new Set(comparisonAttributes));
+        }
+        else {
+            return [];
+        }
+    }
+    getComparisonValueType(comparator) {
+        switch (comparator) {
+            case RolloutRuleComparator.NumberEquals:
+            case RolloutRuleComparator.NumberDoesNotEqual:
+            case RolloutRuleComparator.NumberLess:
+            case RolloutRuleComparator.NumberLessOrEquals:
+            case RolloutRuleComparator.NumberGreater:
+            case RolloutRuleComparator.NumberGreaterOrEquals:
+                return 'number';
+            default:
+                return 'text';
+        }
+    }
+    normalizeComparisonValue(comparator, comparisonValue) {
+        // In the case of number inputs value is a number but API expects
+        // a string, so we need to make sure that it's converted to string.
+        return comparator && this.getComparisonValueType(comparator) === "number"
+            ? FormHelper.normalizeNumberStoredAsString(comparisonValue)
+            : comparisonValue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SettingListFormHelper, deps: [{ token: i1.UntypedFormBuilder }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SettingListFormHelper, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: SettingListFormHelper, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.UntypedFormBuilder }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setting-list-form-helper.js","sourceRoot":"","sources":["../../../../../projects/ng-configcat-publicapi-ui/src/lib/_services/setting-list-form-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SettingValuesModel } from '../_models/settingValuesModel';\nimport { UntypedFormBuilder, Validators, UntypedFormGroup, UntypedFormArray } from '@angular/forms';\nimport { RolloutPercentageItemModel, RolloutRuleComparator, RolloutRuleModel, SettingType, SettingValueModel } from 'ng-configcat-publicapi';\nimport { FormHelper } from './form-helper';\n\n@Injectable({ providedIn: 'root' })\nexport class SettingListFormHelper {\n\n    constructor(private formBuilder: UntypedFormBuilder) { }\n\n    createSettingValuesFormGroup(settingValuesModel: SettingValuesModel) {\n        const formGroup = this.formBuilder.group({\n            settingValues: this.formBuilder.array(\n                settingValuesModel.settingValues.map(sv => {\n                    return this.createSettingValueFormGroup(sv, settingValuesModel.readOnly);\n                })),\n\n            // Decorator\n            environment: this.formBuilder.group({\n                environmentId: [{ value: settingValuesModel.environment.environmentId, disabled: true }],\n                name: [{ value: settingValuesModel.environment.name, disabled: true }],\n            }),\n\n            comparisonAttributes: [[]]\n        });\n\n        const rolloutRules = this.getAllRolloutRules(formGroup);\n        const comparisonAttributes = this.getComparisonAttributes(rolloutRules);\n        formGroup.patchValue({ comparisonAttributes: comparisonAttributes });\n        return formGroup;\n    }\n\n\n    createSettingValueFormGroup(settingValueModel: SettingValueModel, readOnly: boolean) {\n        if (!settingValueModel.setting) {\n            return this.formBuilder.group({});\n        }\n        return this.formBuilder.group({\n            settingId: [settingValueModel.setting.settingId],\n            value: [\n                { value: settingValueModel.value, disabled: readOnly },\n                this.getValidatorsForSettingType(settingValueModel.setting.settingType)\n            ],\n            rolloutPercentageItems: settingValueModel.rolloutPercentageItems\n                ? this.formBuilder.array(settingValueModel.rolloutPercentageItems.map(p => {\n                    // @ts-ignore()\n                    return this.createRolloutPercentageItemFormGroup(p, readOnly, settingValueModel.setting.settingType);\n                }))\n                : this.formBuilder.array([]), rolloutRules: settingValueModel.rolloutRules\n                    ? this.formBuilder.array(settingValueModel.rolloutRules.map(r => {\n                        // @ts-ignore()\n                        return this.createRolloutRuleFormGroup(r, readOnly, settingValueModel.setting.settingType);\n                    }))\n                    : this.formBuilder.array([]),\n\n            updatedAt: [{ value: settingValueModel.updatedAt, disabled: true }],\n            lastUpdaterUserEmail: [{ value: settingValueModel.lastUpdaterUserEmail, disabled: true }],\n            lastUpdaterUserFullName: [{ value: settingValueModel.lastUpdaterUserFullName, disabled: true }],\n\n            rolloutPercentageItemsSum: [{ value: 100, disabled: false }, [Validators.min(100), Validators.max(100)]],\n            // Decoration\n            setting: this.formBuilder.group({\n                settingId: [{ value: settingValueModel.setting.settingId, disabled: true }],\n                key: [{ value: settingValueModel.setting.key, disabled: true }],\n                name: [{ value: settingValueModel.setting.name, disabled: true }],\n                hint: [{ value: settingValueModel.setting.hint, disabled: true }],\n                settingType: [{ value: settingValueModel.setting.settingType, disabled: true }],\n                creatorEmail: [{ value: settingValueModel.setting.creatorEmail, disabled: true }],\n                creatorFullName: [{ value: settingValueModel.setting.creatorFullName, disabled: true }],\n                createdAt: [{ value: settingValueModel.setting.createdAt, disabled: true }]\n            }),\n\n            integrationLinks: settingValueModel.integrationLinks ? this.formBuilder.array(settingValueModel.integrationLinks.map(il => {\n                return this.formBuilder.group({\n                    key: [{ value: il.key, disabled: true }],\n                    description: [{ value: il.description, disabled: true }],\n                    integrationLinkType: [{ value: il.integrationLinkType, disabled: true }],\n                    url: [{ value: il.url, disabled: true }],\n                });\n            })) : this.formBuilder.array([])\n        });\n    }\n\n    createRolloutPercentageItemFormGroup(p: RolloutPercentageItemModel, readOnly: boolean, settingType: SettingType | undefined) {\n        return this.formBuilder.group({\n            percentage: [{ value: p.percentage, disabled: readOnly }, [Validators.required, Validators.min(0), Validators.max(100)]],\n            value: [\n                { value: p.value, disabled: readOnly },\n                this.getValidatorsForSettingType(settingType)\n            ],\n            valueDisabled: [\n                { value: p.value, disabled: true }, // For percentage item value\n            ]\n        });\n    }\n\n    createRolloutRuleFormGroup(r: RolloutRuleModel, readOnly: boolean, settingType: SettingType | undefined) {\n        if (r.comparator) {\n            return this.formBuilder.group({\n                type: [{ value: 0, disabled: true }],\n                comparisonAttribute: [{ value: r.comparisonAttribute, disabled: readOnly }, [Validators.required]],\n                comparator: [{ value: r.comparator, disabled: readOnly }, [Validators.required]],\n                comparisonValue: [{ value: r.comparisonValue, disabled: readOnly }, [Validators.required]],\n                value: [\n                    { value: r.value, disabled: readOnly },\n                    this.getValidatorsForSettingType(settingType)\n                ],\n            });\n        } else if (r.segmentComparator) {\n            return this.formBuilder.group({\n                type: [{ value: 1, disabled: true }],\n                segmentComparator: [{ value: r.segmentComparator, disabled: readOnly }, [Validators.required]],\n                segmentId: [{ value: r.segmentId, disabled: readOnly }, [Validators.required]],\n                value: [\n                    { value: r.value, disabled: readOnly },\n                    this.getValidatorsForSettingType(settingType)\n                ],\n            });\n        } else {\n            throw new Error('Invalid rollout rule');\n        }\n    }\n\n    private getValidatorsForSettingType(settingType: SettingType | undefined) {\n        switch (settingType) {\n            case SettingType.Int:\n                return [Validators.required,\n                Validators.min(-2147483648), Validators.max(2147483647), Validators.pattern('^[-+]?[0-9]\\\\d*$')];\n            case SettingType.Double:\n                return [Validators.required, Validators.min(-1.79769313486232E+308), Validators.max(1.79769313486232E+308)];\n            case SettingType.String:\n            case SettingType.Boolean:\n                return [Validators.required];\n            default:\n                return [];\n        }\n    }\n\n    private getAllRolloutRules(formGroup: UntypedFormGroup) {\n        const settingValues = formGroup.get('settingValues') as UntypedFormArray;\n        const rolloutRules = settingValues.controls.map(cv => (cv.get('rolloutRules') as UntypedFormArray).value);\n        return rolloutRules.length === 0 ? rolloutRules : rolloutRules.reduce((a, b) => a.concat(b));\n    }\n\n    private getComparisonAttributes(rolloutRules: any[]) {\n        if (rolloutRules.length > 0) {\n            const currentComparisonAttributes = rolloutRules.map(r => r.comparisonAttribute);\n\n            const defaultComparisonAttributes = ['Identifier', 'Email', 'Country'];\n            const comparisonAttributes = currentComparisonAttributes.filter(c => defaultComparisonAttributes.indexOf(c) === -1);\n            return Array.from(new Set(comparisonAttributes));\n        } else {\n            return [];\n        }\n    }\n\n    getComparisonValueType(comparator: RolloutRuleComparator) {\n        switch (comparator) {\n            case RolloutRuleComparator.NumberEquals:\n            case RolloutRuleComparator.NumberDoesNotEqual:\n            case RolloutRuleComparator.NumberLess:\n            case RolloutRuleComparator.NumberLessOrEquals:\n            case RolloutRuleComparator.NumberGreater:\n            case RolloutRuleComparator.NumberGreaterOrEquals:\n                return 'number';\n            default:\n                return 'text';\n        }\n    }\n\n    normalizeComparisonValue(comparator: RolloutRuleComparator | undefined, comparisonValue: any) {\n        // In the case of number inputs value is a number but API expects\n        // a string, so we need to make sure that it's converted to string.\n        return comparator && this.getComparisonValueType(comparator) === \"number\"\n            ? FormHelper.normalizeNumberStoredAsString(comparisonValue)\n            : comparisonValue;\n    }\n}\n"]}

package/esm2022/lib/authorization/authorization.component.mjs

@@ -0,0 +1,62 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { FormHelper } from '../_services/form-helper';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../_services";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/input";
+export class AuthorizationComponent {
+    constructor(formBuilder, publicApiService) {
+        this.formBuilder = formBuilder;
+        this.publicApiService = publicApiService;
+        this.basePath = null;
+        this.integrationName = 'ConfigCat Feature Flags';
+        this.authorized = new EventEmitter();
+        this.error = new EventEmitter();
+        this.FormHelper = FormHelper;
+    }
+    ngOnInit() {
+        this.formGroup = this.formBuilder.group({
+            basicAuthUsername: ['', Validators.required],
+            basicAuthPassword: ['', Validators.required],
+        });
+    }
+    onSubmit() {
+        if (!this.formGroup.valid) {
+            return;
+        }
+        const meService = this.publicApiService.createMeService(this.formGroup.controls.basicAuthUsername.value, this.formGroup.controls.basicAuthPassword.value, this.basePath);
+        meService.getMe().subscribe(me => {
+            this.authorized.emit({
+                basicAuthUsername: this.formGroup.controls.basicAuthUsername.value,
+                basicAuthPassword: this.formGroup.controls.basicAuthPassword.value,
+                email: me.email,
+                fullName: me.fullName
+            });
+        }, () => {
+            this.formGroup.setErrors({ invalidAuthorization: 'Invalid Basic auth user name or password' });
+            this.error.emit();
+        });
+    }
+    getPublicApiUrl() {
+        return this.publicApiService.getDashboardBasePath() + '/my-account/public-api-credentials';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AuthorizationComponent, deps: [{ token: i1.UntypedFormBuilder }, { token: i2.PublicApiService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.3", type: AuthorizationComponent, selector: "configcat-authorization", inputs: { basePath: "basePath", integrationName: "integrationName" }, outputs: { authorized: "authorized", error: "error" }, ngImport: i0, template: "<form [formGroup]=\"formGroup\" (ngSubmit)=\"onSubmit()\">\n    <div class=\"container\">\n        <div class=\"form\">\n            <p>\n                In order to use {{integrationName}} you have to authorize first with your ConfigCat Public API\n                credentials.\n            </p>\n            <ul>\n                <li>\n                    <a [href]=\"getPublicApiUrl()\" target=\"_blank\">\n                        Get your Basic Auth user name and password</a> to access ConfigCat Public API.\n                    <br />\n                    <b>Note!</b> Your ConfigCat account's email address and password will not work here.\n                </li>\n                <li>\n                    Type your credentials here and click the Authorize button.\n                </li>\n            </ul>\n\n            <mat-form-field class=\"form-field\" appearance=\"outline\">\n                <mat-label>Basic auth user name</mat-label>\n                <input matInput placeholder=\"Basic auth user name\" formControlName=\"basicAuthUsername\">\n                <mat-error *ngIf=\"formGroup.controls.basicAuthUsername.invalid\">\n                    {{FormHelper.getErrorMessage(formGroup.controls.basicAuthUsername)}}\n                </mat-error>\n            </mat-form-field>\n            <mat-form-field class=\"form-field\" appearance=\"outline\">\n                <mat-label>Basic auth password</mat-label>\n                <input matInput placeholder=\"Basic auth password\" formControlName=\"basicAuthPassword\" type=\"password\"\n                    autocomplete=\"current-password\">\n                <mat-error *ngIf=\"formGroup.controls.basicAuthPassword.invalid\">\n                    {{FormHelper.getErrorMessage(formGroup.controls.basicAuthPassword)}}\n                </mat-error>\n            </mat-form-field>\n            <div>\n                <button mat-flat-button color=\"primary\" type=\"submit\" class=\"submit\">Authorize</button>\n                <mat-error *ngIf=\"formGroup.invalid && formGroup.errors && formGroup.errors.invalidAuthorization\">\n                    {{formGroup.errors.invalidAuthorization}}</mat-error>\n            </div>\n        </div>\n    </div>\n</form>", styles: [".container{display:flex;margin:8px}.form{width:100%}.form-field{width:100%;margin-bottom:8px}.submit{margin-top:8px;margin-bottom:8px}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i4.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i4.MatLabel, selector: "mat-label" }, { kind: "directive", type: i4.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "component", type: i5.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "directive", type: i6.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AuthorizationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'configcat-authorization', template: "<form [formGroup]=\"formGroup\" (ngSubmit)=\"onSubmit()\">\n    <div class=\"container\">\n        <div class=\"form\">\n            <p>\n                In order to use {{integrationName}} you have to authorize first with your ConfigCat Public API\n                credentials.\n            </p>\n            <ul>\n                <li>\n                    <a [href]=\"getPublicApiUrl()\" target=\"_blank\">\n                        Get your Basic Auth user name and password</a> to access ConfigCat Public API.\n                    <br />\n                    <b>Note!</b> Your ConfigCat account's email address and password will not work here.\n                </li>\n                <li>\n                    Type your credentials here and click the Authorize button.\n                </li>\n            </ul>\n\n            <mat-form-field class=\"form-field\" appearance=\"outline\">\n                <mat-label>Basic auth user name</mat-label>\n                <input matInput placeholder=\"Basic auth user name\" formControlName=\"basicAuthUsername\">\n                <mat-error *ngIf=\"formGroup.controls.basicAuthUsername.invalid\">\n                    {{FormHelper.getErrorMessage(formGroup.controls.basicAuthUsername)}}\n                </mat-error>\n            </mat-form-field>\n            <mat-form-field class=\"form-field\" appearance=\"outline\">\n                <mat-label>Basic auth password</mat-label>\n                <input matInput placeholder=\"Basic auth password\" formControlName=\"basicAuthPassword\" type=\"password\"\n                    autocomplete=\"current-password\">\n                <mat-error *ngIf=\"formGroup.controls.basicAuthPassword.invalid\">\n                    {{FormHelper.getErrorMessage(formGroup.controls.basicAuthPassword)}}\n                </mat-error>\n            </mat-form-field>\n            <div>\n                <button mat-flat-button color=\"primary\" type=\"submit\" class=\"submit\">Authorize</button>\n                <mat-error *ngIf=\"formGroup.invalid && formGroup.errors && formGroup.errors.invalidAuthorization\">\n                    {{formGroup.errors.invalidAuthorization}}</mat-error>\n            </div>\n        </div>\n    </div>\n</form>", styles: [".container{display:flex;margin:8px}.form{width:100%}.form-field{width:100%;margin-bottom:8px}.submit{margin-top:8px;margin-bottom:8px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.UntypedFormBuilder }, { type: i2.PublicApiService }], propDecorators: { basePath: [{
+                type: Input
+            }], integrationName: [{
+                type: Input
+            }], authorized: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization.component.js","sourceRoot":"","sources":["../../../../../projects/ng-configcat-publicapi-ui/src/lib/authorization/authorization.component.ts","../../../../../projects/ng-configcat-publicapi-ui/src/lib/authorization/authorization.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAwC,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;;;;;;;;AAOtD,MAAM,OAAO,sBAAsB;IASjC,YACU,WAA+B,EAC/B,gBAAkC;QADlC,gBAAW,GAAX,WAAW,CAAoB;QAC/B,qBAAgB,GAAhB,gBAAgB,CAAkB;QARnC,aAAQ,GAAG,IAAI,CAAC;QAChB,oBAAe,GAAG,yBAAyB,CAAC;QAC3C,eAAU,GAAG,IAAI,YAAY,EAAE,CAAC;QAChC,UAAK,GAAG,IAAI,YAAY,EAAE,CAAC;QACrC,eAAU,GAAG,UAAU,CAAC;IAKpB,CAAC;IAEL,QAAQ;QACN,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;YACtC,iBAAiB,EAAE,CAAC,EAAE,EAAE,UAAU,CAAC,QAAQ,CAAC;YAC5C,iBAAiB,EAAE,CAAC,EAAE,EAAE,UAAU,CAAC,QAAQ,CAAC;SAC7C,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,eAAe,CACrD,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,iBAAiB,CAAC,KAAK,EAC/C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,iBAAiB,CAAC,KAAK,EAC/C,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEjB,SAAS,CAAC,KAAK,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE;YAC/B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;gBACnB,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,iBAAiB,CAAC,KAAK;gBAClE,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,iBAAiB,CAAC,KAAK;gBAClE,KAAK,EAAE,EAAE,CAAC,KAAK;gBACf,QAAQ,EAAE,EAAE,CAAC,QAAQ;aACtB,CAAC,CAAC;QACL,CAAC,EACC,GAAG,EAAE;YACH,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,oBAAoB,EAAE,0CAA0C,EAAE,CAAC,CAAC;YAC/F,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QACpB,CAAC,CACF,CAAC;IACJ,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,EAAE,GAAG,oCAAoC,CAAC;IAC7F,CAAC;8GAhDU,sBAAsB;kGAAtB,sBAAsB,4LCVnC,krEAyCO;;2FD/BM,sBAAsB;kBALlC,SAAS;+BACE,yBAAyB;sHAO1B,QAAQ;sBAAhB,KAAK;gBACG,eAAe;sBAAvB,KAAK;gBACI,UAAU;sBAAnB,MAAM;gBACG,KAAK;sBAAd,MAAM","sourcesContent":["import { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';\nimport { UntypedFormGroup, UntypedFormBuilder, Validators } from '@angular/forms';\nimport { PublicApiService } from '../_services';\nimport { FormHelper } from '../_services/form-helper';\n\n@Component({\n  selector: 'configcat-authorization',\n  templateUrl: './authorization.component.html',\n  styleUrls: ['./authorization.component.scss']\n})\nexport class AuthorizationComponent implements OnInit {\n\n  formGroup!: UntypedFormGroup;\n  @Input() basePath = null;\n  @Input() integrationName = 'ConfigCat Feature Flags';\n  @Output() authorized = new EventEmitter();\n  @Output() error = new EventEmitter();\n  FormHelper = FormHelper;\n\n  constructor(\n    private formBuilder: UntypedFormBuilder,\n    private publicApiService: PublicApiService\n  ) { }\n\n  ngOnInit(): void {\n    this.formGroup = this.formBuilder.group({\n      basicAuthUsername: ['', Validators.required],\n      basicAuthPassword: ['', Validators.required],\n    });\n  }\n\n  onSubmit() {\n    if (!this.formGroup.valid) {\n      return;\n    }\n\n    const meService = this.publicApiService.createMeService(\n      this.formGroup.controls.basicAuthUsername.value,\n      this.formGroup.controls.basicAuthPassword.value,\n      this.basePath);\n\n    meService.getMe().subscribe(me => {\n      this.authorized.emit({\n        basicAuthUsername: this.formGroup.controls.basicAuthUsername.value,\n        basicAuthPassword: this.formGroup.controls.basicAuthPassword.value,\n        email: me.email,\n        fullName: me.fullName\n      });\n    },\n      () => {\n        this.formGroup.setErrors({ invalidAuthorization: 'Invalid Basic auth user name or password' });\n        this.error.emit();\n      }\n    );\n  }\n\n  getPublicApiUrl() {\n    return this.publicApiService.getDashboardBasePath() + '/my-account/public-api-credentials';\n  }\n}\n","<form [formGroup]=\"formGroup\" (ngSubmit)=\"onSubmit()\">\n    <div class=\"container\">\n        <div class=\"form\">\n            <p>\n                In order to use {{integrationName}} you have to authorize first with your ConfigCat Public API\n                credentials.\n            </p>\n            <ul>\n                <li>\n                    <a [href]=\"getPublicApiUrl()\" target=\"_blank\">\n                        Get your Basic Auth user name and password</a> to access ConfigCat Public API.\n                    <br />\n                    <b>Note!</b> Your ConfigCat account's email address and password will not work here.\n                </li>\n                <li>\n                    Type your credentials here and click the Authorize button.\n                </li>\n            </ul>\n\n            <mat-form-field class=\"form-field\" appearance=\"outline\">\n                <mat-label>Basic auth user name</mat-label>\n                <input matInput placeholder=\"Basic auth user name\" formControlName=\"basicAuthUsername\">\n                <mat-error *ngIf=\"formGroup.controls.basicAuthUsername.invalid\">\n                    {{FormHelper.getErrorMessage(formGroup.controls.basicAuthUsername)}}\n                </mat-error>\n            </mat-form-field>\n            <mat-form-field class=\"form-field\" appearance=\"outline\">\n                <mat-label>Basic auth password</mat-label>\n                <input matInput placeholder=\"Basic auth password\" formControlName=\"basicAuthPassword\" type=\"password\"\n                    autocomplete=\"current-password\">\n                <mat-error *ngIf=\"formGroup.controls.basicAuthPassword.invalid\">\n                    {{FormHelper.getErrorMessage(formGroup.controls.basicAuthPassword)}}\n                </mat-error>\n            </mat-form-field>\n            <div>\n                <button mat-flat-button color=\"primary\" type=\"submit\" class=\"submit\">Authorize</button>\n                <mat-error *ngIf=\"formGroup.invalid && formGroup.errors && formGroup.errors.invalidAuthorization\">\n                    {{formGroup.errors.invalidAuthorization}}</mat-error>\n            </div>\n        </div>\n    </div>\n</form>"]}

package/{esm2020 → esm2022}/lib/base/base-select.component.mjs

@@ -10,10 +10,10 @@ export class BaseSelectComponent extends BaseComponent {
     openChanged(event) {
         this.dropdownOpened.emit(event);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: BaseSelectComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.3", type: BaseSelectComponent, selector: "base-select", inputs: { customDropdown: "customDropdown" }, outputs: { dropdownOpened: "dropdownOpened" }, usesInheritance: true, ngImport: i0, template: '<div></div>', isInline: true }); }
 }
-BaseSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BaseSelectComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-BaseSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: BaseSelectComponent, selector: "base-select", inputs: { customDropdown: "customDropdown" }, outputs: { dropdownOpened: "dropdownOpened" }, usesInheritance: true, ngImport: i0, template: '<div></div>', isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BaseSelectComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: BaseSelectComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'base-select',
@@ -24,4 +24,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], dropdownOpened: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1zZWxlY3QuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctY29uZmlnY2F0LXB1YmxpY2FwaS11aS9zcmMvbGliL2Jhc2UvYmFzZS1zZWxlY3QuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDOztBQU1qRCxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsYUFBYTtJQUp0RDs7UUFNVyxtQkFBYyxHQUFZLEtBQUssQ0FBQztRQUUvQixtQkFBYyxHQUFHLElBQUksWUFBWSxFQUFXLENBQUM7S0FLeEQ7SUFIVyxXQUFXLENBQUMsS0FBVTtRQUM5QixJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNsQyxDQUFDOztpSEFSVSxtQkFBbUI7cUdBQW5CLG1CQUFtQix1S0FGcEIsYUFBYTs0RkFFWixtQkFBbUI7a0JBSi9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGFBQWE7b0JBQ3ZCLFFBQVEsRUFBRSxhQUFhO2lCQUN4Qjs4QkFHVSxjQUFjO3NCQUF0QixLQUFLO2dCQUVJLGNBQWM7c0JBQXZCLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSW5wdXQsIE91dHB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmFzZUNvbXBvbmVudCB9IGZyb20gJy4vYmFzZS5jb21wb25lbnQnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdiYXNlLXNlbGVjdCcsXG4gIHRlbXBsYXRlOiAnPGRpdj48L2Rpdj4nXG59KVxuZXhwb3J0IGNsYXNzIEJhc2VTZWxlY3RDb21wb25lbnQgZXh0ZW5kcyBCYXNlQ29tcG9uZW50IHtcblxuICBASW5wdXQoKSBjdXN0b21Ecm9wZG93bjogYm9vbGVhbiA9IGZhbHNlO1xuXG4gIEBPdXRwdXQoKSBkcm9wZG93bk9wZW5lZCA9IG5ldyBFdmVudEVtaXR0ZXI8Ym9vbGVhbj4oKTtcblxuICBwcm90ZWN0ZWQgb3BlbkNoYW5nZWQoZXZlbnQ6IGFueSkge1xuICAgIHRoaXMuZHJvcGRvd25PcGVuZWQuZW1pdChldmVudCk7XG4gIH1cbn1cblxuXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1zZWxlY3QuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctY29uZmlnY2F0LXB1YmxpY2FwaS11aS9zcmMvbGliL2Jhc2UvYmFzZS1zZWxlY3QuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDOztBQU1qRCxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsYUFBYTtJQUp0RDs7UUFNVyxtQkFBYyxHQUFZLEtBQUssQ0FBQztRQUUvQixtQkFBYyxHQUFHLElBQUksWUFBWSxFQUFXLENBQUM7S0FLeEQ7SUFIVyxXQUFXLENBQUMsS0FBVTtRQUM5QixJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNsQyxDQUFDOzhHQVJVLG1CQUFtQjtrR0FBbkIsbUJBQW1CLHVLQUZwQixhQUFhOzsyRkFFWixtQkFBbUI7a0JBSi9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGFBQWE7b0JBQ3ZCLFFBQVEsRUFBRSxhQUFhO2lCQUN4Qjs4QkFHVSxjQUFjO3NCQUF0QixLQUFLO2dCQUVJLGNBQWM7c0JBQXZCLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSW5wdXQsIE91dHB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmFzZUNvbXBvbmVudCB9IGZyb20gJy4vYmFzZS5jb21wb25lbnQnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdiYXNlLXNlbGVjdCcsXG4gIHRlbXBsYXRlOiAnPGRpdj48L2Rpdj4nXG59KVxuZXhwb3J0IGNsYXNzIEJhc2VTZWxlY3RDb21wb25lbnQgZXh0ZW5kcyBCYXNlQ29tcG9uZW50IHtcblxuICBASW5wdXQoKSBjdXN0b21Ecm9wZG93bjogYm9vbGVhbiA9IGZhbHNlO1xuXG4gIEBPdXRwdXQoKSBkcm9wZG93bk9wZW5lZCA9IG5ldyBFdmVudEVtaXR0ZXI8Ym9vbGVhbj4oKTtcblxuICBwcm90ZWN0ZWQgb3BlbkNoYW5nZWQoZXZlbnQ6IGFueSkge1xuICAgIHRoaXMuZHJvcGRvd25PcGVuZWQuZW1pdChldmVudCk7XG4gIH1cbn1cblxuXG4iXX0=