ng-configcat-publicapi-ui 3.0.8 → 4.0.0

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

@@ -0,0 +1,359 @@
+import { Injectable } from "@angular/core";
+import { FormArray, FormControl, FormGroup, Validators } from "@angular/forms";
+import { UserComparator, UserComparatorType, SettingType, PrerequisiteComparator } from "../bootstrap";
+import { valid } from 'semver';
+import { percentageRegex, wholeNumberRegex } from "../_services/form-helper";
+import * as i0 from "@angular/core";
+export class FormGenerator {
+    generateSettingValuesFormGroup(model, readOnly, settings, featureFlagLimitations) {
+        return new FormGroup({
+            defaultValue: this.generateValueFormGroup(model.defaultValue, model.setting.settingType, readOnly, featureFlagLimitations),
+            percentageEvaluationAttribute: this.generatePercentageEvaluationAttributeFormControl(model.percentageEvaluationAttribute, readOnly),
+            targetingRules: new FormArray(model.targetingRules.map(ft => this.generateTargetingRuleFormGroup(ft, model.setting.settingType, readOnly, settings, featureFlagLimitations)))
+        });
+    }
+    generatePercentageEvaluationAttributeFormControl(percentageEvaluationAttribute, readOnly) {
+        return new FormControl({ value: percentageEvaluationAttribute, disabled: readOnly }, { validators: [this.validateEmptyString, Validators.maxLength(1000)] });
+    }
+    generateTargetingRuleFormGroup(model, settingType, readOnly, settings, featureFlagLimitations) {
+        const conditions = new FormArray(model.conditions.map(tr => this.generateConditionFormGroup(tr, readOnly, settings, featureFlagLimitations)));
+        if (model.percentageOptions?.length > 0) {
+            return new FormGroup({
+                conditions,
+                percentageOptions: new FormArray(model.percentageOptions.map(pr => this.generatePercentageOptionFormGroup(pr, settingType, readOnly, featureFlagLimitations)), [this.validatePercentageSum])
+            });
+        }
+        else if (model.value) {
+            return new FormGroup({
+                conditions,
+                value: this.generateValueFormGroup(model.value, settingType, readOnly, featureFlagLimitations)
+            });
+        }
+        throw Error("Invalid model");
+    }
+    generateTargetingRuleWithEmptyPercentageOptions(settingType, readOnly, settings, featureFlagLimitations) {
+        return this.generateTargetingRuleFormGroup({
+            conditions: [],
+            percentageOptions: this.getEmptyPercentageOptions(settingType)
+        }, settingType, readOnly, settings, featureFlagLimitations);
+    }
+    getEmptyPercentageOptions(settingType) {
+        switch (settingType) {
+            case SettingType.Boolean:
+                return [
+                    { percentage: 50, value: { boolValue: true } },
+                    { percentage: 50, value: { boolValue: false } }
+                ];
+            case SettingType.String:
+            case SettingType.Int:
+            case SettingType.Double:
+                return [
+                    { percentage: 50, value: {} },
+                    { percentage: 50, value: {} },
+                ];
+            default:
+                throw new Error('Invalid SettingType');
+        }
+    }
+    generatePercentageOptionFormGroup(model, settingType, readOnly, featureFlagLimitations) {
+        return new FormGroup({
+            percentage: new FormControl({ value: model.percentage, disabled: readOnly }, { nonNullable: true, validators: [this.validateNumberNan, Validators.required, Validators.min(0), Validators.max(100), Validators.pattern(percentageRegex)] }),
+            value: this.generateValueFormGroup(model.value, settingType, readOnly || settingType === SettingType.Boolean, featureFlagLimitations),
+        });
+    }
+    generateConditionFormGroup(model, readOnly, settings, featureFlagLimitations) {
+        if (model.userCondition) {
+            return new FormGroup({
+                userCondition: this.generateUserConditionFormGroup(model.userCondition, readOnly, featureFlagLimitations)
+            });
+        }
+        else if (model.segmentCondition) {
+            return new FormGroup({
+                segmentCondition: this.generateSegmentConditionFormGroup(model.segmentCondition, readOnly)
+            });
+        }
+        else if (model.prerequisiteFlagCondition) {
+            return new FormGroup({
+                prerequisiteFlagCondition: this.generatePrerequisiteFlagConditionFormGroup(model.prerequisiteFlagCondition, readOnly, settings, featureFlagLimitations)
+            });
+        }
+        else {
+            throw new Error('');
+        }
+    }
+    generateUserConditionFormGroup(value, readOnly, featureFlagLimitations) {
+        return new FormGroup({
+            comparisonAttribute: new FormControl({ value: value.comparisonAttribute, disabled: readOnly }, { nonNullable: true, validators: [Validators.required, Validators.maxLength(1000)] }),
+            comparator: new FormControl({ value: value.comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),
+            comparisonValue: this.generateComparisonValueFormGroup(value.comparisonValue, value.comparator, readOnly, featureFlagLimitations)
+        });
+    }
+    generateSegmentConditionFormGroup(value, readOnly) {
+        return new FormGroup({
+            segmentId: new FormControl({ value: value.segmentId, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),
+            comparator: new FormControl({ value: value.comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),
+        });
+    }
+    generatePrerequisiteFlagConditionFormGroup(value, readOnly, settings, featureFlagLimitations) {
+        const setting = settings.filter(s => s.settingId == value.prerequisiteSettingId)[0];
+        if (!setting) {
+            throw new Error('Could not find prerequisite setting');
+        }
+        if (setting.settingType === SettingType.Boolean) {
+            // In case of a boolean prerequisite setting, we are enforcing a 'True' prerequisiteComparisonValue 
+            // so we can simplify the UI with a simple 'Is true' or 'Is false' select.
+            // 'Is true' = PrerequisiteComparator.Equals TRUE
+            // 'Is false' = PrerequisiteComparator.DoesNotEqual TRUE
+            let comparator = value.comparator;
+            if (!value.prerequisiteComparisonValue) {
+                // If the prerequisiteComparisonValue is false somehow (e.g. Public Management API), we should negate the comparator.
+                comparator = comparator === PrerequisiteComparator.Equals ? PrerequisiteComparator.DoesNotEqual : PrerequisiteComparator.Equals;
+            }
+            return new FormGroup({
+                prerequisiteSettingId: new FormControl({ value: value.prerequisiteSettingId, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),
+                comparator: new FormControl({ value: comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),
+                prerequisiteComparisonValue: this.generateValueFormGroup({ boolValue: true }, setting.settingType, readOnly, featureFlagLimitations)
+            });
+        }
+        else {
+            return new FormGroup({
+                prerequisiteSettingId: new FormControl({ value: value.prerequisiteSettingId, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),
+                comparator: new FormControl({ value: value.comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),
+                prerequisiteComparisonValue: this.generateValueFormGroup(value.prerequisiteComparisonValue, setting.settingType, readOnly, featureFlagLimitations)
+            });
+        }
+    }
+    generateEmptyPrerequisiteFlagConditionFormGroup(featureFlagLimitations) {
+        return new FormGroup({
+            prerequisiteSettingId: new FormControl(null, { nonNullable: true, validators: [Validators.required] }),
+            comparator: new FormControl(PrerequisiteComparator.Equals, { nonNullable: true, validators: [Validators.required] }),
+            prerequisiteComparisonValue: this.generateValueFormGroup({ boolValue: true }, SettingType.Boolean, false, featureFlagLimitations)
+        });
+    }
+    getNextIndex(formArray) {
+        if (formArray.controls.length === 0) {
+            return 0;
+        }
+        return Math.max(...formArray.controls.map(c => c.controls.index.value)) + 1;
+    }
+    generateComparisonValueListFormGroup(listValue, readOnly, validators, index) {
+        return new FormGroup({
+            value: new FormControl({ value: listValue.value, disabled: readOnly }, { nonNullable: true, validators }),
+            hint: new FormControl({ value: listValue.hint, disabled: readOnly }, [Validators.maxLength(1500)]),
+            // The index column is generated on the first generation by default or by the getNextIndex() if a value is added to the listvalue. It is required so we can delete the rows on the poput editor.
+            index: new FormControl({ value: index, disabled: true })
+        });
+    }
+    generateComparisonValueFormGroup(value, comparator, readOnly, featureFlagLimitations) {
+        switch (this.getComparisonValueType(comparator)) {
+            case UserComparatorType.String:
+                return new FormGroup({
+                    stringValue: new FormControl({ value: value.stringValue, disabled: readOnly }, { nonNullable: true, validators: this.getComparisonValueStringValidators(featureFlagLimitations) })
+                });
+            case UserComparatorType.StringList:
+                return new FormGroup({
+                    listValue: this.generateComparisonValueListValueArray(value.listValue, readOnly, featureFlagLimitations, this.getComparisonValueStringListItemValidators(featureFlagLimitations))
+                });
+            case UserComparatorType.Number:
+                return new FormGroup({
+                    doubleValue: new FormControl({ value: value.doubleValue, disabled: readOnly }, 
+                    // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+                    { nonNullable: true, validators: [this.validateNumberNan, Validators.required, Validators.min(-1.79769313486232E+308), Validators.max(1.79769313486232E+308)] })
+                });
+            case UserComparatorType.Semver:
+                return new FormGroup({
+                    stringValue: new FormControl({ value: value.stringValue, disabled: readOnly }, { nonNullable: true, validators: this.getComparisonValueSemverValidators(featureFlagLimitations) })
+                });
+            case UserComparatorType.SemverList:
+                return new FormGroup({
+                    listValue: this.generateComparisonValueListValueArray(value.listValue, readOnly, featureFlagLimitations, this.getComparisonValueSemverListItemValidators(featureFlagLimitations))
+                });
+            case UserComparatorType.DateTime:
+                return new FormGroup({
+                    doubleValue: new FormControl({ value: value.doubleValue, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] })
+                });
+            default: throw new Error('Invalid comparator');
+        }
+    }
+    generateComparisonValueListValueArray(listValue, readOnly, featureFlagLimitations, itemValidators) {
+        return new FormArray((listValue ?? []).map((lv, index) => { return this.generateComparisonValueListFormGroup(lv, readOnly, itemValidators, index); }), [Validators.required, Validators.minLength(1), Validators.maxLength(featureFlagLimitations.maxComparisonValueListLength)]);
+    }
+    getComparisonValueStringValidators(featureFlagLimitations) {
+        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueLength)];
+    }
+    getComparisonValueStringListItemValidators(featureFlagLimitations) {
+        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueListItemLength)];
+    }
+    getComparisonValueSemverValidators(featureFlagLimitations) {
+        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueLength), this.validateSemVer];
+    }
+    getComparisonValueSemverListItemValidators(featureFlagLimitations) {
+        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueListItemLength), this.validateSemVer];
+    }
+    generateDefaultValue(settingType) {
+        switch (settingType) {
+            case SettingType.Boolean:
+                return { boolValue: false };
+            case SettingType.String:
+            case SettingType.Int:
+            case SettingType.Double:
+                return {};
+            default:
+                throw new Error('Invalid SettingType');
+        }
+    }
+    generateDefaultValueFormGroup(settingType, readOnly, featureFlagLimitations) {
+        return this.generateValueFormGroup(this.generateDefaultValue(settingType), settingType, readOnly, featureFlagLimitations);
+    }
+    generateValueFormGroup(value, settingType, readOnly, featureFlagLimitations) {
+        switch (settingType) {
+            case SettingType.Boolean:
+                return new FormGroup({
+                    boolValue: new FormControl({ value: value.boolValue, disabled: readOnly }, { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })
+                });
+            case SettingType.String:
+                return new FormGroup({
+                    stringValue: new FormControl({ value: value.stringValue, disabled: readOnly }, { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })
+                });
+            case SettingType.Int:
+                return new FormGroup({
+                    intValue: new FormControl({ value: value.intValue, disabled: readOnly }, { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })
+                });
+            case SettingType.Double:
+                return new FormGroup({
+                    doubleValue: new FormControl({ value: value.doubleValue, disabled: readOnly }, { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })
+                });
+            default:
+                throw new Error('Invalid SettingType');
+        }
+    }
+    getComparisonValueType(comparator) {
+        switch (comparator) {
+            case UserComparator.SensitiveTextEquals:
+            case UserComparator.SensitiveTextDoesNotEqual:
+            case UserComparator.TextEquals:
+            case UserComparator.TextDoesNotEqual:
+                return UserComparatorType.String;
+            case UserComparator.SensitiveIsOneOf:
+            case UserComparator.SensitiveIsNotOneOf:
+            case UserComparator.SensitiveTextStartsWithAnyOf:
+            case UserComparator.SensitiveTextEndsWithAnyOf:
+            case UserComparator.SensitiveTextNotStartsWithAnyOf:
+            case UserComparator.SensitiveTextNotEndsWithAnyOf:
+            case UserComparator.SensitiveArrayContainsAnyOf:
+            case UserComparator.SensitiveArrayDoesNotContainAnyOf:
+            case UserComparator.IsOneOf:
+            case UserComparator.IsNotOneOf:
+            case UserComparator.TextStartsWithAnyOf:
+            case UserComparator.TextEndsWithAnyOf:
+            case UserComparator.TextNotStartsWithAnyOf:
+            case UserComparator.TextNotEndsWithAnyOf:
+            case UserComparator.ArrayContainsAnyOf:
+            case UserComparator.ArrayDoesNotContainAnyOf:
+            case UserComparator.ContainsAnyOf:
+            case UserComparator.DoesNotContainAnyOf:
+                return UserComparatorType.StringList;
+            case UserComparator.NumberEquals:
+            case UserComparator.NumberDoesNotEqual:
+            case UserComparator.NumberLess:
+            case UserComparator.NumberLessOrEquals:
+            case UserComparator.NumberGreater:
+            case UserComparator.NumberGreaterOrEquals:
+                return UserComparatorType.Number;
+            case UserComparator.SemVerIsOneOf:
+            case UserComparator.SemVerIsNotOneOf:
+                return UserComparatorType.SemverList;
+            case UserComparator.SemVerGreater:
+            case UserComparator.SemVerGreaterOrEquals:
+            case UserComparator.SemVerLess:
+            case UserComparator.SemVerLessOrEquals:
+                return UserComparatorType.Semver;
+            case UserComparator.DateTimeBefore:
+            case UserComparator.DateTimeAfter:
+                return UserComparatorType.DateTime;
+            default:
+                throw new Error('Invalid comparator');
+        }
+    }
+    getValidatorsForSettingType(settingType, featureFlagLimitations) {
+        switch (settingType) {
+            case SettingType.Int:
+                return [this.validateNumberNan, Validators.required,
+                    Validators.min(-2147483648), Validators.max(2147483647), Validators.pattern(wholeNumberRegex)];
+            case SettingType.Double:
+                // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+                return [this.validateNumberNan, Validators.required, Validators.min(-1.79769313486232E+308), Validators.max(1.79769313486232E+308)];
+            case SettingType.String:
+                return [Validators.required, Validators.maxLength(featureFlagLimitations.maxStringFlagValueLength ?? 100000)];
+            case SettingType.Boolean:
+                return [Validators.required];
+            default:
+                return [];
+        }
+    }
+    validateNumberNan(c) {
+        if (c.value === null || isNaN(c.value)) {
+            return {
+                validateNumberNan: {
+                    valid: false
+                }
+            };
+        }
+        return null;
+    }
+    validateSemVer(c) {
+        if (valid(c.value) === null) {
+            return {
+                validateSemVer: {
+                    valid: false
+                }
+            };
+        }
+        return null;
+    }
+    validateEmptyString(c) {
+        if (c.value === '') {
+            return {
+                required: true
+            };
+        }
+        return null;
+    }
+    validatePercentageSum(c) {
+        if (c?.controls.map(i => i.controls.percentage.value).reduce((a, b) => { return a + b; }, 0) !== 100) {
+            return {
+                validatePercentageSum: {
+                    valid: false
+                }
+            };
+        }
+        return null;
+    }
+    isPercentageOnlyTargetingRule(formGroup) {
+        return !formGroup.controls.value
+            && !formGroup.controls.conditions.length
+            && !!formGroup.controls.percentageOptions?.length;
+    }
+    addComparisonValueListValueItems(userComparator, listValueFormArray, comparisonValueList, featureFlagLimitations) {
+        const validators = this.getComparisonValueType(userComparator) === UserComparatorType.SemverList
+            ? this.getComparisonValueSemverListItemValidators(featureFlagLimitations)
+            : this.getComparisonValueStringListItemValidators(featureFlagLimitations);
+        const maxIndex = this.getNextIndex(listValueFormArray);
+        comparisonValueList.forEach((comparisonValueListItem, index) => {
+            const formGroup = this.generateComparisonValueListFormGroup(comparisonValueListItem, false, validators, maxIndex + index);
+            formGroup.updateValueAndValidity();
+            formGroup.markAsDirty();
+            formGroup.markAllAsTouched();
+            listValueFormArray.push(formGroup, { emitEvent: false });
+        });
+        listValueFormArray.updateValueAndValidity();
+        listValueFormArray.markAsTouched();
+        listValueFormArray.markAsDirty();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: FormGenerator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: FormGenerator }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: FormGenerator, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-generator.js","sourceRoot":"","sources":["../../../../../projects/ng-configcat-publicapi-ui/src/lib/_services/form-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { FormArray, FormControl, FormGroup, ValidatorFn, Validators } from \"@angular/forms\";\nimport {\n    UserComparator, UserComparatorType, SettingType,\n    IComparisonValueModel, IComparisonValueListModel,\n    IFeatureFlagLimitations,\n    ComparisonValueForm, ComparisonValueListForm,\n    ConditionForm,\n    PrerequisiteFlagConditionForm,\n    IPrerequisiteSetting,\n    PercentageOptionForm,\n    SegmentConditionForm,\n    TargetingRuleForm,\n    UpdateSettingValueForm, UserConditionForm, ValueForm,\n    PrerequisiteComparator, IConditionModel, IPrerequisiteFlagConditionModel, ISegmentConditionModel, IUserConditionModel,\n    IValueModel, ITargetingRuleModel, IPercentageOptionModel, ISettingValueModel\n} from \"../bootstrap\";\nimport { valid } from 'semver';\nimport { percentageRegex, wholeNumberRegex } from \"../_services/form-helper\";\n\n@Injectable()\nexport class FormGenerator {\n    public generateSettingValuesFormGroup(model: ISettingValueModel, readOnly: boolean, settings: IPrerequisiteSetting[], featureFlagLimitations: IFeatureFlagLimitations): FormGroup<UpdateSettingValueForm> {\n        return new FormGroup<UpdateSettingValueForm>({\n            defaultValue: this.generateValueFormGroup(model.defaultValue, model.setting.settingType, readOnly, featureFlagLimitations),\n            percentageEvaluationAttribute: this.generatePercentageEvaluationAttributeFormControl(model.percentageEvaluationAttribute, readOnly),\n            targetingRules: new FormArray<FormGroup<TargetingRuleForm>>(\n                model.targetingRules.map(ft => this.generateTargetingRuleFormGroup(ft, model.setting.settingType, readOnly, settings, featureFlagLimitations))\n            )\n        });\n    }\n\n    public generatePercentageEvaluationAttributeFormControl(percentageEvaluationAttribute: string, readOnly: boolean) {\n        return new FormControl({ value: percentageEvaluationAttribute, disabled: readOnly }, { validators: [this.validateEmptyString, Validators.maxLength(1000)] })\n    }\n\n    public generateTargetingRuleFormGroup(model: ITargetingRuleModel, settingType: SettingType, readOnly: boolean, settings: IPrerequisiteSetting[], featureFlagLimitations: IFeatureFlagLimitations): FormGroup<TargetingRuleForm> {\n        const conditions = new FormArray<FormGroup<ConditionForm>>(\n            model.conditions.map(tr => this.generateConditionFormGroup(tr, readOnly, settings, featureFlagLimitations))\n        )\n\n        if (model.percentageOptions?.length > 0) {\n            return new FormGroup<TargetingRuleForm>({\n                conditions,\n                percentageOptions: new FormArray<FormGroup<PercentageOptionForm>>(\n                    model.percentageOptions.map(pr => this.generatePercentageOptionFormGroup(pr, settingType, readOnly, featureFlagLimitations)),\n                    [this.validatePercentageSum]\n                )\n            });\n        } else if (model.value) {\n            return new FormGroup<TargetingRuleForm>({\n                conditions,\n                value: this.generateValueFormGroup(model.value, settingType, readOnly, featureFlagLimitations)\n            });\n        }\n\n        throw Error(\"Invalid model\");\n    }\n\n    public generateTargetingRuleWithEmptyPercentageOptions(settingType: SettingType, readOnly: boolean, settings: IPrerequisiteSetting[], featureFlagLimitations: IFeatureFlagLimitations): FormGroup<TargetingRuleForm> {\n        return this.generateTargetingRuleFormGroup({\n            conditions: [],\n            percentageOptions: this.getEmptyPercentageOptions(settingType)\n        }, settingType, readOnly, settings, featureFlagLimitations);\n    }\n\n    public getEmptyPercentageOptions(settingType: SettingType): IPercentageOptionModel[] {\n        switch (settingType) {\n            case SettingType.Boolean:\n                return [\n                    { percentage: 50, value: { boolValue: true } },\n                    { percentage: 50, value: { boolValue: false } }\n                ];\n            case SettingType.String:\n            case SettingType.Int:\n            case SettingType.Double:\n                return [\n                    { percentage: 50, value: {} },\n                    { percentage: 50, value: {} },\n                ];\n            default:\n                throw new Error('Invalid SettingType');\n        }\n    }\n\n    public generatePercentageOptionFormGroup(model: IPercentageOptionModel, settingType: SettingType, readOnly: boolean, featureFlagLimitations: IFeatureFlagLimitations): FormGroup<PercentageOptionForm> {\n        return new FormGroup<PercentageOptionForm>({\n            percentage: new FormControl({ value: model.percentage, disabled: readOnly }, { nonNullable: true, validators: [this.validateNumberNan, Validators.required, Validators.min(0), Validators.max(100), Validators.pattern(percentageRegex)] }),\n            value: this.generateValueFormGroup(model.value, settingType, readOnly || settingType === SettingType.Boolean, featureFlagLimitations),\n        })\n    }\n\n    public generateConditionFormGroup(model: IConditionModel, readOnly: boolean, settings: IPrerequisiteSetting[], featureFlagLimitations: IFeatureFlagLimitations): FormGroup<ConditionForm> {\n        if (model.userCondition) {\n            return new FormGroup<ConditionForm>({\n                userCondition: this.generateUserConditionFormGroup(model.userCondition, readOnly, featureFlagLimitations)\n            });\n        } else if (model.segmentCondition) {\n            return new FormGroup<ConditionForm>({\n                segmentCondition: this.generateSegmentConditionFormGroup(model.segmentCondition, readOnly)\n            });\n        } else if (model.prerequisiteFlagCondition) {\n            return new FormGroup<ConditionForm>({\n                prerequisiteFlagCondition: this.generatePrerequisiteFlagConditionFormGroup(model.prerequisiteFlagCondition, readOnly, settings, featureFlagLimitations)\n            });\n        } else {\n            throw new Error('')\n        }\n    }\n\n    public generateUserConditionFormGroup(value: IUserConditionModel, readOnly: boolean, featureFlagLimitations: IFeatureFlagLimitations): FormGroup<UserConditionForm> {\n        return new FormGroup<UserConditionForm>({\n            comparisonAttribute: new FormControl({ value: value.comparisonAttribute, disabled: readOnly }, { nonNullable: true, validators: [Validators.required, Validators.maxLength(1000)] }),\n            comparator: new FormControl({ value: value.comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),\n            comparisonValue: this.generateComparisonValueFormGroup(value.comparisonValue, value.comparator, readOnly, featureFlagLimitations)\n        });\n    }\n\n    public generateSegmentConditionFormGroup(value: ISegmentConditionModel, readOnly: boolean): FormGroup<SegmentConditionForm> {\n        return new FormGroup<SegmentConditionForm>({\n            segmentId: new FormControl({ value: value.segmentId, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),\n            comparator: new FormControl({ value: value.comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),\n        });\n    }\n\n    public generatePrerequisiteFlagConditionFormGroup(value: IPrerequisiteFlagConditionModel, readOnly: boolean, settings: IPrerequisiteSetting[], featureFlagLimitations: IFeatureFlagLimitations): FormGroup<PrerequisiteFlagConditionForm> {\n        const setting = settings.filter(s => s.settingId == value.prerequisiteSettingId)[0];\n        if (!setting) {\n            throw new Error('Could not find prerequisite setting');\n        }\n        if (setting.settingType === SettingType.Boolean) {\n            // In case of a boolean prerequisite setting, we are enforcing a 'True' prerequisiteComparisonValue \n            // so we can simplify the UI with a simple 'Is true' or 'Is false' select.\n            // 'Is true' = PrerequisiteComparator.Equals TRUE\n            // 'Is false' = PrerequisiteComparator.DoesNotEqual TRUE\n            let comparator = value.comparator;\n            if (!value.prerequisiteComparisonValue) {\n                // If the prerequisiteComparisonValue is false somehow (e.g. Public Management API), we should negate the comparator.\n                comparator = comparator === PrerequisiteComparator.Equals ? PrerequisiteComparator.DoesNotEqual : PrerequisiteComparator.Equals;\n            }\n            return new FormGroup<PrerequisiteFlagConditionForm>({\n                prerequisiteSettingId: new FormControl({ value: value.prerequisiteSettingId, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),\n                comparator: new FormControl({ value: comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),\n                prerequisiteComparisonValue: this.generateValueFormGroup({ boolValue: true }, setting.settingType, readOnly, featureFlagLimitations)\n            });\n        } else {\n            return new FormGroup<PrerequisiteFlagConditionForm>({\n                prerequisiteSettingId: new FormControl({ value: value.prerequisiteSettingId, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),\n                comparator: new FormControl({ value: value.comparator, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] }),\n                prerequisiteComparisonValue: this.generateValueFormGroup(value.prerequisiteComparisonValue, setting.settingType, readOnly, featureFlagLimitations)\n            });\n        }\n    }\n\n    public generateEmptyPrerequisiteFlagConditionFormGroup(featureFlagLimitations: IFeatureFlagLimitations): FormGroup<PrerequisiteFlagConditionForm> {\n        return new FormGroup<PrerequisiteFlagConditionForm>({\n            prerequisiteSettingId: new FormControl(null, { nonNullable: true, validators: [Validators.required] }),\n            comparator: new FormControl(PrerequisiteComparator.Equals, { nonNullable: true, validators: [Validators.required] }),\n            prerequisiteComparisonValue: this.generateValueFormGroup({ boolValue: true }, SettingType.Boolean, false, featureFlagLimitations)\n        });\n    }\n\n    public getNextIndex(formArray: FormArray<FormGroup<ComparisonValueListForm>>) {\n        if (formArray.controls.length === 0) {\n            return 0;\n        }\n        return Math.max(...formArray.controls.map(c => c.controls.index.value)) + 1;\n    }\n\n    public generateComparisonValueListFormGroup(listValue: IComparisonValueListModel, readOnly: boolean, validators: ValidatorFn[], index: number) {\n        return new FormGroup<ComparisonValueListForm>({\n            value: new FormControl({ value: listValue.value, disabled: readOnly }, { nonNullable: true, validators }),\n            hint: new FormControl({ value: listValue.hint, disabled: readOnly }, [Validators.maxLength(1500)]),\n            // The index column is generated on the first generation by default or by the getNextIndex() if a value is added to the listvalue. It is required so we can delete the rows on the poput editor.\n            index: new FormControl({ value: index, disabled: true })\n        });\n    }\n\n    public generateComparisonValueFormGroup(value: IComparisonValueModel, comparator: UserComparator, readOnly: boolean, featureFlagLimitations: IFeatureFlagLimitations): FormGroup<ComparisonValueForm> {\n        switch (this.getComparisonValueType(comparator)) {\n            case UserComparatorType.String:\n                return new FormGroup<ComparisonValueForm>({\n                    stringValue: new FormControl({ value: value.stringValue, disabled: readOnly }, { nonNullable: true, validators: this.getComparisonValueStringValidators(featureFlagLimitations) })\n                });\n            case UserComparatorType.StringList:\n                return new FormGroup<ComparisonValueForm>({\n                    listValue: this.generateComparisonValueListValueArray(value.listValue, readOnly, featureFlagLimitations, this.getComparisonValueStringListItemValidators(featureFlagLimitations))\n                });\n\n            case UserComparatorType.Number:\n                return new FormGroup<ComparisonValueForm>({\n                    doubleValue: new FormControl({ value: value.doubleValue, disabled: readOnly },\n                        // eslint-disable-next-line @typescript-eslint/no-loss-of-precision\n                        { nonNullable: true, validators: [this.validateNumberNan, Validators.required, Validators.min(-1.79769313486232E+308), Validators.max(1.79769313486232E+308)] })\n                });\n\n            case UserComparatorType.Semver:\n                return new FormGroup<ComparisonValueForm>({\n                    stringValue: new FormControl({ value: value.stringValue, disabled: readOnly }, { nonNullable: true, validators: this.getComparisonValueSemverValidators(featureFlagLimitations) })\n                });\n            case UserComparatorType.SemverList:\n                return new FormGroup<ComparisonValueForm>({\n                    listValue: this.generateComparisonValueListValueArray(value.listValue, readOnly, featureFlagLimitations, this.getComparisonValueSemverListItemValidators(featureFlagLimitations))\n                });\n\n            case UserComparatorType.DateTime:\n                return new FormGroup<ComparisonValueForm>({\n                    doubleValue: new FormControl({ value: value.doubleValue, disabled: readOnly }, { nonNullable: true, validators: [Validators.required] })\n                });\n\n            default: throw new Error('Invalid comparator');\n        }\n    }\n\n    public generateComparisonValueListValueArray(listValue: IComparisonValueListModel[], readOnly: boolean, featureFlagLimitations: IFeatureFlagLimitations, itemValidators: ValidatorFn[]) {\n        return new FormArray<FormGroup<ComparisonValueListForm>>(\n            (listValue ?? []).map((lv, index) => { return this.generateComparisonValueListFormGroup(lv, readOnly, itemValidators, index); }),\n            [Validators.required, Validators.minLength(1), Validators.maxLength(featureFlagLimitations.maxComparisonValueListLength)]\n        )\n    }\n\n    public getComparisonValueStringValidators(featureFlagLimitations: IFeatureFlagLimitations) {\n        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueLength)];\n    }\n\n    public getComparisonValueStringListItemValidators(featureFlagLimitations: IFeatureFlagLimitations) {\n        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueListItemLength)];\n    }\n\n    public getComparisonValueSemverValidators(featureFlagLimitations: IFeatureFlagLimitations) {\n        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueLength), this.validateSemVer]\n    }\n\n    public getComparisonValueSemverListItemValidators(featureFlagLimitations: IFeatureFlagLimitations) {\n        return [Validators.required, Validators.maxLength(featureFlagLimitations.maxComparisonValueListItemLength), this.validateSemVer]\n    }\n\n    public generateDefaultValue(settingType: SettingType): IValueModel {\n        switch (settingType) {\n            case SettingType.Boolean:\n                return { boolValue: false };\n            case SettingType.String:\n            case SettingType.Int:\n            case SettingType.Double:\n                return {};\n            default:\n                throw new Error('Invalid SettingType');\n        }\n    }\n\n    public generateDefaultValueFormGroup(settingType: SettingType, readOnly: boolean, featureFlagLimitations: IFeatureFlagLimitations): FormGroup<ValueForm> {\n        return this.generateValueFormGroup(this.generateDefaultValue(settingType), settingType, readOnly, featureFlagLimitations);\n    }\n\n    public generateValueFormGroup(value: IValueModel, settingType: SettingType, readOnly: boolean, featureFlagLimitations: IFeatureFlagLimitations): FormGroup<ValueForm> {\n        switch (settingType) {\n            case SettingType.Boolean:\n                return new FormGroup<ValueForm>({\n                    boolValue: new FormControl({ value: value.boolValue, disabled: readOnly },\n                        { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })\n                });\n\n            case SettingType.String:\n                return new FormGroup<ValueForm>({\n                    stringValue: new FormControl({ value: value.stringValue, disabled: readOnly },\n                        { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })\n                });\n\n            case SettingType.Int:\n                return new FormGroup<ValueForm>({\n                    intValue: new FormControl({ value: value.intValue, disabled: readOnly },\n                        { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })\n                });\n\n            case SettingType.Double:\n                return new FormGroup<ValueForm>({\n                    doubleValue: new FormControl({ value: value.doubleValue, disabled: readOnly },\n                        { nonNullable: true, validators: this.getValidatorsForSettingType(settingType, featureFlagLimitations) })\n                });\n\n            default:\n                throw new Error('Invalid SettingType');\n        }\n    }\n\n    public getComparisonValueType(comparator: UserComparator): UserComparatorType {\n        switch (comparator) {\n\n            case UserComparator.SensitiveTextEquals:\n            case UserComparator.SensitiveTextDoesNotEqual:\n            case UserComparator.TextEquals:\n            case UserComparator.TextDoesNotEqual:\n                return UserComparatorType.String;\n\n            case UserComparator.SensitiveIsOneOf:\n            case UserComparator.SensitiveIsNotOneOf:\n            case UserComparator.SensitiveTextStartsWithAnyOf:\n            case UserComparator.SensitiveTextEndsWithAnyOf:\n            case UserComparator.SensitiveTextNotStartsWithAnyOf:\n            case UserComparator.SensitiveTextNotEndsWithAnyOf:\n            case UserComparator.SensitiveArrayContainsAnyOf:\n            case UserComparator.SensitiveArrayDoesNotContainAnyOf:\n            case UserComparator.IsOneOf:\n            case UserComparator.IsNotOneOf:\n            case UserComparator.TextStartsWithAnyOf:\n            case UserComparator.TextEndsWithAnyOf:\n            case UserComparator.TextNotStartsWithAnyOf:\n            case UserComparator.TextNotEndsWithAnyOf:\n            case UserComparator.ArrayContainsAnyOf:\n            case UserComparator.ArrayDoesNotContainAnyOf:\n            case UserComparator.ContainsAnyOf:\n            case UserComparator.DoesNotContainAnyOf:\n                return UserComparatorType.StringList;\n\n            case UserComparator.NumberEquals:\n            case UserComparator.NumberDoesNotEqual:\n            case UserComparator.NumberLess:\n            case UserComparator.NumberLessOrEquals:\n            case UserComparator.NumberGreater:\n            case UserComparator.NumberGreaterOrEquals:\n                return UserComparatorType.Number;\n\n            case UserComparator.SemVerIsOneOf:\n            case UserComparator.SemVerIsNotOneOf:\n                return UserComparatorType.SemverList;\n\n            case UserComparator.SemVerGreater:\n            case UserComparator.SemVerGreaterOrEquals:\n            case UserComparator.SemVerLess:\n            case UserComparator.SemVerLessOrEquals:\n                return UserComparatorType.Semver;\n\n            case UserComparator.DateTimeBefore:\n            case UserComparator.DateTimeAfter:\n                return UserComparatorType.DateTime;\n\n            default:\n                throw new Error('Invalid comparator');\n        }\n    }\n\n\n    getValidatorsForSettingType(settingType: SettingType, featureFlagLimitations: IFeatureFlagLimitations): ValidatorFn[] {\n        switch (settingType) {\n            case SettingType.Int:\n                return [this.validateNumberNan, Validators.required,\n                Validators.min(-2147483648), Validators.max(2147483647), Validators.pattern(wholeNumberRegex)];\n            case SettingType.Double:\n                // eslint-disable-next-line @typescript-eslint/no-loss-of-precision\n                return [this.validateNumberNan, Validators.required, Validators.min(-1.79769313486232E+308), Validators.max(1.79769313486232E+308)];\n            case SettingType.String:\n                return [Validators.required, Validators.maxLength(featureFlagLimitations.maxStringFlagValueLength ?? 100000)];\n            case SettingType.Boolean:\n                return [Validators.required];\n            default:\n                return [];\n        }\n    }\n\n    validateNumberNan(c: FormControl<number>) {\n        if (c.value === null || isNaN(c.value)) {\n            return {\n                validateNumberNan: {\n                    valid: false\n                }\n            };\n        }\n        return null;\n    }\n\n    validateSemVer(c: FormControl<string>) {\n        if (valid(c.value) === null) {\n            return {\n                validateSemVer: {\n                    valid: false\n                }\n            };\n        }\n        return null;\n    }\n\n    validateEmptyString(c: FormControl<string>) {\n        if (c.value === '') {\n            return {\n                required: true\n            };\n        }\n        return null;\n    }\n\n    validatePercentageSum(c: FormArray<FormGroup<PercentageOptionForm>>) {\n        if (c?.controls.map(i => i.controls.percentage.value).reduce((a, b) => { return a + b }, 0) !== 100) {\n            return {\n                validatePercentageSum: {\n                    valid: false\n                }\n            };\n        }\n        return null;\n    }\n\n    isPercentageOnlyTargetingRule(formGroup: FormGroup<TargetingRuleForm>): boolean {\n        return !formGroup.controls.value\n            && !formGroup.controls.conditions.length\n            && !!formGroup.controls.percentageOptions?.length;\n    }\n\n    addComparisonValueListValueItems(\n        userComparator: UserComparator,\n        listValueFormArray: FormArray<FormGroup<ComparisonValueListForm>>,\n        comparisonValueList: IComparisonValueListModel[],\n        featureFlagLimitations: IFeatureFlagLimitations) {\n        const validators =\n            this.getComparisonValueType(userComparator) === UserComparatorType.SemverList\n                ? this.getComparisonValueSemverListItemValidators(featureFlagLimitations)\n                : this.getComparisonValueStringListItemValidators(featureFlagLimitations);\n\n        const maxIndex = this.getNextIndex(listValueFormArray);\n\n        comparisonValueList.forEach(\n            (comparisonValueListItem, index) => {\n                const formGroup = this.generateComparisonValueListFormGroup(comparisonValueListItem, false, validators, maxIndex + index);\n                formGroup.updateValueAndValidity();\n                formGroup.markAsDirty();\n                formGroup.markAllAsTouched();\n                listValueFormArray.push(formGroup, { emitEvent: false });\n            });\n\n        listValueFormArray.updateValueAndValidity();\n        listValueFormArray.markAsTouched();\n        listValueFormArray.markAsDirty();\n    }\n}\n"]}

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

@@ -0,0 +1,107 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { PlatformHelper } from './platform-helper';
+export const percentageRegex = '^[0-9]*$';
+export const wholeNumberRegex = '^[-+]?[0-9]\\d*$';
+export const timeRegex = /^([0-9]|0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/;
+export class FormHelper {
+    static getErrorMessage(control, hint = '') {
+        if (!control || control.valid) {
+            return null;
+        }
+        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 null;
+    }
+    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 const percentageRegex = '^[0-9]*$';\nexport const wholeNumberRegex = '^[-+]?[0-9]\\\\d*$';\nexport const timeRegex = /^([0-9]|0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/;\n\nexport class FormHelper {\n\n    public static getErrorMessage(control: AbstractControl, hint: string = '') {\n        if (!control || control.valid) {\n            return null;\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 null;\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/esm2022/lib/_services/messaging.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+export class MessagingService {
+    constructor(snackBar) {
+        this.snackBar = snackBar;
+    }
+    showErrorSnack(message = 'Something went wrong.', action = 'Dismiss', durationMs = 60000) {
+        this.snackBar.open(`Ooops. ${message} Please try again or contact us.`, action, { duration: durationMs, panelClass: 'red-snackbar' });
+    }
+    showSuccessSnack(message = 'Success.', action = null, durationMs = 2500) {
+        this.snackBar.open(message, action, { duration: durationMs, panelClass: 'green-snackbar' });
+    }
+    showWarningSnack(message = 'Success.', action = 'Dismiss', durationMs = 5000) {
+        this.snackBar.open(message, action, { duration: durationMs, panelClass: 'yellow-snackbar' });
+    }
+    dismissCurrentSnack() {
+        this.snackBar.dismiss();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MessagingService, deps: [{ token: i1.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MessagingService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: MessagingService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.MatSnackBar }] });
+//# sourceMappingURL=data:application/json;base64,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