@festo-ui/angular 3.1.0 → 3.2.0

package/esm2020/lib/forms/forms.module.mjs

@@ -0,0 +1,146 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { ObserversModule } from '@angular/cdk/observers';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CheckboxComponent } from './checkbox/checkbox.component';
+import { SwitchComponent } from './switch/switch.component';
+import { RadioComponent, RadioGroupDirective } from './radio/radio.component';
+import { UniqueSelectionDispatcher } from './unique-selection-dispatcher';
+import { SelectComponent } from './select/select.component';
+import { TextInputComponent } from './text-input/text-input.component';
+import { TextAreaComponent } from './text-area/text-area.component';
+import { ColorPickerComponent } from './color-picker/color-picker.component';
+import { SliderComponent } from './slider/slider.component';
+import { ColorIndicatorComponent } from './color-indicator/color-indicator.component';
+import { SegmentComponent } from './segment/segment.component';
+import { SegmentControlComponent } from './segment/segment-control/segment-control.component';
+import { DatePickerComponent } from './date-picker/date-picker.component';
+import { FlatpickrComponent } from '../wrappers/flatpickr/flatpickr.component';
+import { DateRangePickerComponent } from './date-range-picker/date-range-picker.component';
+import { TimePickerComponent } from './time-picker/time-picker.component';
+import { TimePickerDropdownComponent } from './time-picker/time-picker-dropdown/time-picker-dropdown.component';
+import { TextEditorComponent } from './text-editor/text-editor.component';
+import { ChipTextPipe } from './select/chip-text.pipe';
+import { SelectOptionComponent } from './select/select-option/select-option.component';
+import * as i0 from "@angular/core";
+export * from './checkbox/checkbox.component';
+export * from './switch/switch.component';
+export * from './radio/radio.component';
+export * from './select/select.component';
+export * from './select/select-option/select-option.component';
+export * from './select/chip-text.pipe';
+export * from './text-input/text-input.component';
+export * from './text-area/text-area.component';
+export * from './color-picker/color-picker.component';
+export * from './slider/slider.component';
+export * from './color-indicator/color-indicator.component';
+export * from './segment/segment.component';
+export * from './segment/segment-control/segment-control.component';
+export * from './date-picker/date-picker.component';
+export * from './date-range-picker/date-range-picker.component';
+export * from './time-picker/time-picker.component';
+export * from './time-picker/time-picker-dropdown/time-picker-dropdown.component';
+export * from './text-editor/text-editor.component';
+export { ValueAccessorBaseDirective as ValueAccessorBase } from './value-accessor-base';
+export { ContainerHostDirective as ContainerHost } from './container-host';
+export class FestoAngularFormsModule {
+}
+FestoAngularFormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FestoAngularFormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FestoAngularFormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FestoAngularFormsModule, declarations: [CheckboxComponent,
+        SwitchComponent,
+        RadioGroupDirective,
+        RadioComponent,
+        TextInputComponent,
+        TextAreaComponent,
+        ColorIndicatorComponent,
+        FlatpickrComponent,
+        DatePickerComponent,
+        DateRangePickerComponent,
+        ColorPickerComponent,
+        SelectComponent,
+        SelectOptionComponent,
+        SliderComponent,
+        SegmentComponent,
+        SegmentControlComponent,
+        TimePickerComponent,
+        TimePickerDropdownComponent,
+        TextEditorComponent,
+        ChipTextPipe], imports: [ReactiveFormsModule, FormsModule, CommonModule, OverlayModule, ScrollingModule, DragDropModule, ObserversModule], exports: [ReactiveFormsModule,
+        FormsModule,
+        CheckboxComponent,
+        SwitchComponent,
+        RadioGroupDirective,
+        RadioComponent,
+        TextInputComponent,
+        TextAreaComponent,
+        ColorIndicatorComponent,
+        DatePickerComponent,
+        DateRangePickerComponent,
+        ColorPickerComponent,
+        SelectComponent,
+        SelectOptionComponent,
+        SliderComponent,
+        SegmentComponent,
+        SegmentControlComponent,
+        TimePickerComponent,
+        TimePickerDropdownComponent,
+        TextEditorComponent,
+        ChipTextPipe] });
+FestoAngularFormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FestoAngularFormsModule, providers: [UniqueSelectionDispatcher], imports: [[ReactiveFormsModule, FormsModule, CommonModule, OverlayModule, ScrollingModule, DragDropModule, ObserversModule], ReactiveFormsModule,
+        FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FestoAngularFormsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        CheckboxComponent,
+                        SwitchComponent,
+                        RadioGroupDirective,
+                        RadioComponent,
+                        TextInputComponent,
+                        TextAreaComponent,
+                        ColorIndicatorComponent,
+                        FlatpickrComponent,
+                        DatePickerComponent,
+                        DateRangePickerComponent,
+                        ColorPickerComponent,
+                        SelectComponent,
+                        SelectOptionComponent,
+                        SliderComponent,
+                        SegmentComponent,
+                        SegmentControlComponent,
+                        TimePickerComponent,
+                        TimePickerDropdownComponent,
+                        TextEditorComponent,
+                        ChipTextPipe
+                    ],
+                    imports: [ReactiveFormsModule, FormsModule, CommonModule, OverlayModule, ScrollingModule, DragDropModule, ObserversModule],
+                    exports: [
+                        ReactiveFormsModule,
+                        FormsModule,
+                        CheckboxComponent,
+                        SwitchComponent,
+                        RadioGroupDirective,
+                        RadioComponent,
+                        TextInputComponent,
+                        TextAreaComponent,
+                        ColorIndicatorComponent,
+                        DatePickerComponent,
+                        DateRangePickerComponent,
+                        ColorPickerComponent,
+                        SelectComponent,
+                        SelectOptionComponent,
+                        SliderComponent,
+                        SegmentComponent,
+                        SegmentControlComponent,
+                        TimePickerComponent,
+                        TimePickerDropdownComponent,
+                        TextEditorComponent,
+                        ChipTextPipe
+                    ],
+                    providers: [UniqueSelectionDispatcher]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forms.module.js","sourceRoot":"","sources":["../../../../../../libs/angular/src/lib/forms/forms.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { OverlayModule } from '@angular/cdk/overlay';\nimport { ScrollingModule } from '@angular/cdk/scrolling';\nimport { DragDropModule } from '@angular/cdk/drag-drop';\nimport { ObserversModule } from '@angular/cdk/observers';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\n\nimport { CheckboxComponent } from './checkbox/checkbox.component';\nimport { SwitchComponent } from './switch/switch.component';\nimport { RadioComponent, RadioGroupDirective } from './radio/radio.component';\nimport { UniqueSelectionDispatcher } from './unique-selection-dispatcher';\nimport { SelectComponent } from './select/select.component';\nimport { TextInputComponent } from './text-input/text-input.component';\nimport { TextAreaComponent } from './text-area/text-area.component';\nimport { ColorPickerComponent } from './color-picker/color-picker.component';\nimport { SliderComponent } from './slider/slider.component';\nimport { ColorIndicatorComponent } from './color-indicator/color-indicator.component';\nimport { SegmentComponent } from './segment/segment.component';\nimport { SegmentControlComponent } from './segment/segment-control/segment-control.component';\nimport { DatePickerComponent } from './date-picker/date-picker.component';\nimport { FlatpickrComponent } from '../wrappers/flatpickr/flatpickr.component';\nimport { DateRangePickerComponent } from './date-range-picker/date-range-picker.component';\nimport { TimePickerComponent } from './time-picker/time-picker.component';\nimport { TimePickerDropdownComponent } from './time-picker/time-picker-dropdown/time-picker-dropdown.component';\nimport { TextEditorComponent } from './text-editor/text-editor.component';\n\nexport * from './checkbox/checkbox.component';\nexport * from './switch/switch.component';\nexport * from './radio/radio.component';\nexport * from './select/select.component';\nexport * from './select/select-option/select-option.component';\nexport * from './select/chip-text.pipe';\nexport * from './text-input/text-input.component';\nexport * from './text-area/text-area.component';\nexport * from './color-picker/color-picker.component';\nexport * from './slider/slider.component';\nexport * from './color-indicator/color-indicator.component';\nexport * from './segment/segment.component';\nexport * from './segment/segment-control/segment-control.component';\nexport * from './date-picker/date-picker.component';\nexport * from './date-range-picker/date-range-picker.component';\nexport * from './time-picker/time-picker.component';\nexport * from './time-picker/time-picker-dropdown/time-picker-dropdown.component';\nexport * from './text-editor/text-editor.component';\nexport { ValueAccessorBaseDirective as ValueAccessorBase } from './value-accessor-base';\nexport { ContainerHostDirective as ContainerHost } from './container-host';\nimport { ChipTextPipe } from './select/chip-text.pipe';\nimport { SelectOptionComponent } from './select/select-option/select-option.component';\n\n@NgModule({\n  declarations: [\n    CheckboxComponent,\n    SwitchComponent,\n    RadioGroupDirective,\n    RadioComponent,\n    TextInputComponent,\n    TextAreaComponent,\n    ColorIndicatorComponent,\n    FlatpickrComponent,\n    DatePickerComponent,\n    DateRangePickerComponent,\n    ColorPickerComponent,\n    SelectComponent,\n    SelectOptionComponent,\n    SliderComponent,\n    SegmentComponent,\n    SegmentControlComponent,\n    TimePickerComponent,\n    TimePickerDropdownComponent,\n    TextEditorComponent,\n    ChipTextPipe\n  ],\n  imports: [ReactiveFormsModule, FormsModule, CommonModule, OverlayModule, ScrollingModule, DragDropModule, ObserversModule],\n  exports: [\n    ReactiveFormsModule,\n    FormsModule,\n    CheckboxComponent,\n    SwitchComponent,\n    RadioGroupDirective,\n    RadioComponent,\n    TextInputComponent,\n    TextAreaComponent,\n    ColorIndicatorComponent,\n    DatePickerComponent,\n    DateRangePickerComponent,\n    ColorPickerComponent,\n    SelectComponent,\n    SelectOptionComponent,\n    SliderComponent,\n    SegmentComponent,\n    SegmentControlComponent,\n    TimePickerComponent,\n    TimePickerDropdownComponent,\n    TextEditorComponent,\n    ChipTextPipe\n  ],\n  providers: [UniqueSelectionDispatcher]\n})\nexport class FestoAngularFormsModule {}\n"]}

package/esm2020/lib/forms/radio/radio.component.mjs

@@ -0,0 +1,346 @@
+import { Component, Input, ChangeDetectionStrategy, Optional, EventEmitter, Output, ChangeDetectorRef, ViewEncapsulation, Directive, forwardRef, ContentChildren, HostBinding } from '@angular/core';
+import { UniqueSelectionDispatcher } from '../unique-selection-dispatcher';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "../unique-selection-dispatcher";
+import * as i2 from "@angular/common";
+export class RadioChange {
+    constructor(source, value) {
+        this.source = source;
+        this.value = value;
+    }
+}
+let nextUniqueId = 0;
+export class RadioGroupDirective {
+    constructor(changeDetector) {
+        this.changeDetector = changeDetector;
+        this.hostClass = true;
+        this.role = 'radiogroup';
+        this.change = new EventEmitter();
+        this.isLarge = false;
+        this.isDisabled = false;
+        this.isRequired = false;
+        this.innerValue = null;
+        this.isInitialized = false;
+        this.isSelected = null;
+        this.innerName = `fngRadioGroup-${nextUniqueId++}`;
+        this.innerLabelPosition = 'before';
+    }
+    get name() {
+        return this.innerName;
+    }
+    set name(value) {
+        this.innerName = value;
+        this.updateRadioButtonNames();
+    }
+    get large() {
+        return this.isLarge;
+    }
+    set large(v) {
+        this.isLarge = v;
+        this.updateRadioButtonSize();
+    }
+    get labelPosition() {
+        return this.innerLabelPosition;
+    }
+    set labelPosition(v) {
+        this.innerLabelPosition = v;
+        this.markRadiosForCheck();
+    }
+    get value() {
+        return this.innerValue;
+    }
+    set value(newValue) {
+        if (this.innerValue !== newValue) {
+            this.innerValue = newValue;
+            this.updateSelectedRadioFromValue();
+            this.checkSelectedRadioButton();
+        }
+    }
+    get selected() {
+        return this.isSelected;
+    }
+    set selected(selected) {
+        this.isSelected = selected;
+        this.value = selected ? selected.value : null;
+        this.checkSelectedRadioButton();
+    }
+    get disabled() {
+        return this.isDisabled;
+    }
+    set disabled(value) {
+        this.isDisabled = coerceBooleanProperty(value);
+        this.markRadiosForCheck();
+    }
+    get required() {
+        return this.isRequired;
+    }
+    set required(value) {
+        this.isRequired = coerceBooleanProperty(value);
+        this.markRadiosForCheck();
+    }
+    ngAfterContentInit() {
+        this.isInitialized = true;
+    }
+    checkSelectedRadioButton() {
+        if (this.isSelected && !this.isSelected.checked) {
+            this.isSelected.checked = true;
+        }
+    }
+    touch() {
+        if (this.onTouched != null) {
+            this.onTouched();
+        }
+    }
+    emitChangeEvent() {
+        if (this.isInitialized) {
+            this.change.emit(new RadioChange(this.isSelected, this.innerValue));
+        }
+    }
+    markRadiosForCheck() {
+        if (this.radios) {
+            this.radios.forEach(radio => radio.markForCheck());
+        }
+    }
+    writeValue(value) {
+        this.value = value;
+        this.changeDetector.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.controlValueAccessorChangeFn = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.changeDetector.markForCheck();
+    }
+    updateRadioButtonSize() {
+        if (this.radios) {
+            this.radios.forEach(radio => {
+                radio.large = this.large;
+                radio.markForCheck();
+            });
+        }
+    }
+    updateRadioButtonNames() {
+        if (this.radios) {
+            this.radios.forEach(radio => {
+                radio.name = this.name;
+                radio.markForCheck();
+            });
+        }
+    }
+    updateSelectedRadioFromValue() {
+        const isAlreadySelected = this.isSelected !== null && this.isSelected.value === this.innerValue;
+        if (this.radios && !isAlreadySelected) {
+            this.isSelected = null;
+            this.radios.forEach(radio => {
+                radio.checked = this.value === radio.value;
+                if (radio.checked) {
+                    this.isSelected = radio;
+                }
+            });
+        }
+    }
+}
+RadioGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: RadioGroupDirective, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+RadioGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: RadioGroupDirective, selector: "[fngRadioGroup]", inputs: { name: "name", large: "large", labelPosition: "labelPosition", value: "value", selected: "selected", disabled: "disabled", required: "required" }, outputs: { change: "change" }, host: { properties: { "class.fwe-radio-group": "this.hostClass", "attr.role": "this.role" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => RadioGroupDirective),
+            multi: true
+        }
+    ], queries: [{ propertyName: "radios", predicate: i0.forwardRef(function () { return RadioComponent; }), descendants: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: RadioGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fngRadioGroup]',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => RadioGroupDirective),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { hostClass: [{
+                type: HostBinding,
+                args: ['class.fwe-radio-group']
+            }], role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], change: [{
+                type: Output
+            }], radios: [{
+                type: ContentChildren,
+                args: [forwardRef(() => RadioComponent), { descendants: true }]
+            }], name: [{
+                type: Input
+            }], large: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }] } });
+export class RadioComponent {
+    constructor(radioGroup, changeDetector, radioDispatcher) {
+        this.changeDetector = changeDetector;
+        this.radioDispatcher = radioDispatcher;
+        this.innerId = `fng-radio-${++nextUniqueId}`;
+        this.change = new EventEmitter();
+        this.isLarge = false;
+        this.isChecked = false;
+        this.innerValue = null;
+        this.radioGroup = radioGroup;
+        this.removeUniqueSelectionListener = radioDispatcher.listen((id, name) => {
+            if (id !== this.id && name === this.name) {
+                this.checked = false;
+            }
+        });
+    }
+    get id() {
+        return this.innerId;
+    }
+    set id(value) {
+        this.innerId = value ? `${value}-${++nextUniqueId}` : `fng-radio-${++nextUniqueId}`;
+    }
+    get inputId() {
+        return `${this.innerId}-input`;
+    }
+    get checked() {
+        return this.isChecked;
+    }
+    set checked(value) {
+        const newCheckedState = coerceBooleanProperty(value);
+        if (this.isChecked !== newCheckedState) {
+            this.isChecked = newCheckedState;
+            if (newCheckedState && this.radioGroup && this.radioGroup.value !== this.value) {
+                this.radioGroup.selected = this;
+            }
+            else if (!newCheckedState && this.radioGroup && this.radioGroup.value === this.value) {
+                this.radioGroup.selected = null;
+            }
+            if (newCheckedState) {
+                this.radioDispatcher.notify(this.id, this.name);
+            }
+            this.changeDetector.markForCheck();
+        }
+    }
+    get value() {
+        return this.innerValue;
+    }
+    set value(value) {
+        if (this.innerValue !== value) {
+            this.innerValue = value;
+            if (this.radioGroup !== null) {
+                if (!this.checked) {
+                    this.checked = this.radioGroup.value === value;
+                }
+                if (this.checked) {
+                    this.radioGroup.selected = this;
+                }
+            }
+        }
+    }
+    get large() {
+        return this.isLarge || (this.radioGroup != null && this.radioGroup.large);
+    }
+    set large(value) {
+        this.isLarge = value;
+    }
+    get labelPosition() {
+        return this.innerLabelPosition || (this.radioGroup && this.radioGroup.labelPosition) || 'before';
+    }
+    set labelPosition(value) {
+        this.innerLabelPosition = value;
+    }
+    get disabled() {
+        return this.isDisabled || (this.radioGroup != null && this.radioGroup.disabled);
+    }
+    set disabled(value) {
+        const newDisabledState = coerceBooleanProperty(value);
+        if (this.isDisabled !== newDisabledState) {
+            this.isDisabled = newDisabledState;
+            this.changeDetector.markForCheck();
+        }
+    }
+    get required() {
+        return this.isRequired || (this.radioGroup && this.radioGroup.required);
+    }
+    set required(value) {
+        this.isRequired = coerceBooleanProperty(value);
+    }
+    ngOnInit() {
+        if (this.radioGroup) {
+            this.checked = this.radioGroup.value === this.innerValue;
+            this.name = this.radioGroup.name;
+        }
+    }
+    ngOnDestroy() {
+        if (this.removeUniqueSelectionListener != null) {
+            this.removeUniqueSelectionListener();
+        }
+    }
+    onInputClick(event) {
+        event.stopPropagation();
+    }
+    onInputChange(event) {
+        event.stopPropagation();
+        if (!this.disabled) {
+            const groupValueChanged = this.radioGroup && this.value !== this.radioGroup.value;
+            this.checked = true;
+            this.emitChangeEvent();
+            if (this.radioGroup) {
+                if (typeof this.radioGroup?.controlValueAccessorChangeFn === 'function') {
+                    this.radioGroup?.controlValueAccessorChangeFn(this.value);
+                }
+                if (groupValueChanged) {
+                    this.radioGroup.emitChangeEvent();
+                }
+            }
+        }
+    }
+    markForCheck() {
+        this.changeDetector.markForCheck();
+    }
+    emitChangeEvent() {
+        this.change.emit(new RadioChange(this, this.innerValue));
+    }
+}
+RadioComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: RadioComponent, deps: [{ token: RadioGroupDirective, optional: true }, { token: i0.ChangeDetectorRef }, { token: i1.UniqueSelectionDispatcher }], target: i0.ɵɵFactoryTarget.Component });
+RadioComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: RadioComponent, selector: "fng-radio", inputs: { name: "name", id: "id", checked: "checked", value: "value", large: "large", labelPosition: "labelPosition", disabled: "disabled", required: "required" }, outputs: { change: "change" }, ngImport: i0, template: "<label\n  [attr.for]=\"inputId\"\n  [ngClass]=\"{\n    'fwe-radio': true,\n    'fwe-radio-label-below': labelPosition == 'below',\n    'fwe-radio-label-before': labelPosition == 'before',\n    'fwe-radio-lg': large\n  }\"\n>\n  <input\n    type=\"radio\"\n    [id]=\"inputId\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    [attr.value]=\"value\"\n    [required]=\"required\"\n    (change)=\"onInputChange($event)\"\n    (click)=\"onInputClick($event)\"\n  />\n  <div class=\"fwe-radio-checkmark\"></div>\n  <div class=\"fwe-radio-label-content\">\n    <ng-content></ng-content>\n  </div>\n</label>\n", styles: [".fwe-radio:hover .fwe-radio-checkmark{background-color:var(--fwe-control)}\n"], directives: [{ type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: RadioComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fng-radio', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<label\n  [attr.for]=\"inputId\"\n  [ngClass]=\"{\n    'fwe-radio': true,\n    'fwe-radio-label-below': labelPosition == 'below',\n    'fwe-radio-label-before': labelPosition == 'before',\n    'fwe-radio-lg': large\n  }\"\n>\n  <input\n    type=\"radio\"\n    [id]=\"inputId\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    [attr.value]=\"value\"\n    [required]=\"required\"\n    (change)=\"onInputChange($event)\"\n    (click)=\"onInputClick($event)\"\n  />\n  <div class=\"fwe-radio-checkmark\"></div>\n  <div class=\"fwe-radio-label-content\">\n    <ng-content></ng-content>\n  </div>\n</label>\n", styles: [".fwe-radio:hover .fwe-radio-checkmark{background-color:var(--fwe-control)}\n"] }]
+        }], ctorParameters: function () { return [{ type: RadioGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef }, { type: i1.UniqueSelectionDispatcher }]; }, propDecorators: { name: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], checked: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], large: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/src/lib/forms/radio/radio.component.ts","../../../../../../../libs/angular/src/lib/forms/radio/radio.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  Input,\n  ChangeDetectionStrategy,\n  Optional,\n  EventEmitter,\n  Output,\n  ChangeDetectorRef,\n  OnDestroy,\n  ViewEncapsulation,\n  Directive,\n  forwardRef,\n  AfterContentInit,\n  ContentChildren,\n  HostBinding\n} from '@angular/core';\nimport type { QueryList } from '@angular/core';\nimport { UniqueSelectionDispatcher } from '../unique-selection-dispatcher';\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\nexport class RadioChange {\n  constructor(public source: RadioComponent, public value: any) {}\n}\n\nlet nextUniqueId = 0;\n\n@Directive({\n  selector: '[fngRadioGroup]',\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => RadioGroupDirective),\n      multi: true\n    }\n  ]\n})\nexport class RadioGroupDirective implements AfterContentInit, ControlValueAccessor {\n  @HostBinding('class.fwe-radio-group') hostClass = true;\n  @HostBinding('attr.role') role = 'radiogroup';\n\n  @Output()\n  readonly change = new EventEmitter<RadioChange>();\n\n  @ContentChildren(forwardRef(() => RadioComponent), { descendants: true })\n  radios: QueryList<RadioComponent>;\n\n  @Input()\n  get name(): string {\n    return this.innerName;\n  }\n  set name(value: string) {\n    this.innerName = value;\n    this.updateRadioButtonNames();\n  }\n\n  @Input()\n  get large() {\n    return this.isLarge;\n  }\n  set large(v) {\n    this.isLarge = v;\n    this.updateRadioButtonSize();\n  }\n\n  @Input()\n  get labelPosition() {\n    return this.innerLabelPosition;\n  }\n  set labelPosition(v) {\n    this.innerLabelPosition = v;\n    this.markRadiosForCheck();\n  }\n\n  @Input()\n  get value(): any {\n    return this.innerValue;\n  }\n  set value(newValue: any) {\n    if (this.innerValue !== newValue) {\n      this.innerValue = newValue;\n      this.updateSelectedRadioFromValue();\n      this.checkSelectedRadioButton();\n    }\n  }\n\n  @Input()\n  get selected() {\n    return this.isSelected;\n  }\n  set selected(selected: any | null) {\n    this.isSelected = selected;\n    this.value = selected ? selected.value : null;\n    this.checkSelectedRadioButton();\n  }\n\n  @Input()\n  get disabled(): boolean {\n    return this.isDisabled;\n  }\n  set disabled(value) {\n    this.isDisabled = coerceBooleanProperty(value);\n    this.markRadiosForCheck();\n  }\n\n  @Input()\n  get required(): boolean {\n    return this.isRequired;\n  }\n  set required(value: boolean) {\n    this.isRequired = coerceBooleanProperty(value);\n    this.markRadiosForCheck();\n  }\n\n  private isLarge = false;\n  private isDisabled = false;\n  private isRequired = false;\n  private innerValue: any = null;\n  private isInitialized = false;\n  private isSelected: RadioComponent | null = null;\n  private innerName = `fngRadioGroup-${nextUniqueId++}`;\n  private innerLabelPosition: 'before' | 'after' | 'below' = 'before';\n\n  constructor(private changeDetector: ChangeDetectorRef) {}\n\n  controlValueAccessorChangeFn: (value: any) => void;\n\n  onTouched: () => void;\n\n  ngAfterContentInit() {\n    this.isInitialized = true;\n  }\n\n  checkSelectedRadioButton() {\n    if (this.isSelected && !this.isSelected.checked) {\n      this.isSelected.checked = true;\n    }\n  }\n\n  touch() {\n    if (this.onTouched != null) {\n      this.onTouched();\n    }\n  }\n\n  emitChangeEvent(): void {\n    if (this.isInitialized) {\n      this.change.emit(new RadioChange(this.isSelected, this.innerValue));\n    }\n  }\n\n  markRadiosForCheck() {\n    if (this.radios) {\n      this.radios.forEach(radio => radio.markForCheck());\n    }\n  }\n\n  writeValue(value: any) {\n    this.value = value;\n    this.changeDetector.markForCheck();\n  }\n\n  registerOnChange(fn: (value: any) => void) {\n    this.controlValueAccessorChangeFn = fn;\n  }\n\n  registerOnTouched(fn: any) {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n    this.changeDetector.markForCheck();\n  }\n\n  private updateRadioButtonSize(): void {\n    if (this.radios) {\n      this.radios.forEach(radio => {\n        radio.large = this.large;\n        radio.markForCheck();\n      });\n    }\n  }\n\n  private updateRadioButtonNames(): void {\n    if (this.radios) {\n      this.radios.forEach(radio => {\n        radio.name = this.name;\n        radio.markForCheck();\n      });\n    }\n  }\n\n  private updateSelectedRadioFromValue(): void {\n    const isAlreadySelected = this.isSelected !== null && this.isSelected.value === this.innerValue;\n    if (this.radios && !isAlreadySelected) {\n      this.isSelected = null;\n      this.radios.forEach(radio => {\n        radio.checked = this.value === radio.value;\n        if (radio.checked) {\n          this.isSelected = radio;\n        }\n      });\n    }\n  }\n}\n\n@Component({\n  selector: 'fng-radio',\n  templateUrl: './radio.component.html',\n  styleUrls: ['./radio.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None\n})\nexport class RadioComponent implements OnInit, OnDestroy {\n  @Input() name: string;\n\n  private innerId = `fng-radio-${++nextUniqueId}`;\n  get id(): string {\n    return this.innerId;\n  }\n  @Input()\n  set id(value: string) {\n    this.innerId = value ? `${value}-${++nextUniqueId}` : `fng-radio-${++nextUniqueId}`;\n  }\n\n  get inputId(): string {\n    return `${this.innerId}-input`;\n  }\n\n  @Input()\n  get checked(): boolean {\n    return this.isChecked;\n  }\n  set checked(value: boolean) {\n    const newCheckedState = coerceBooleanProperty(value);\n    if (this.isChecked !== newCheckedState) {\n      this.isChecked = newCheckedState;\n      if (newCheckedState && this.radioGroup && this.radioGroup.value !== this.value) {\n        this.radioGroup.selected = this;\n      } else if (!newCheckedState && this.radioGroup && this.radioGroup.value === this.value) {\n        this.radioGroup.selected = null;\n      }\n\n      if (newCheckedState) {\n        this.radioDispatcher.notify(this.id, this.name);\n      }\n      this.changeDetector.markForCheck();\n    }\n  }\n\n  @Input()\n  get value(): any {\n    return this.innerValue;\n  }\n  set value(value: any) {\n    if (this.innerValue !== value) {\n      this.innerValue = value;\n      if (this.radioGroup !== null) {\n        if (!this.checked) {\n          this.checked = this.radioGroup.value === value;\n        }\n        if (this.checked) {\n          this.radioGroup.selected = this;\n        }\n      }\n    }\n  }\n\n  @Input()\n  get large() {\n    return this.isLarge || (this.radioGroup != null && this.radioGroup.large);\n  }\n  set large(value) {\n    this.isLarge = value;\n  }\n\n  @Input()\n  get labelPosition() {\n    return this.innerLabelPosition || (this.radioGroup && this.radioGroup.labelPosition) || 'before';\n  }\n  set labelPosition(value) {\n    this.innerLabelPosition = value;\n  }\n\n  @Input()\n  get disabled(): boolean {\n    return this.isDisabled || (this.radioGroup != null && this.radioGroup.disabled);\n  }\n  set disabled(value: boolean) {\n    const newDisabledState = coerceBooleanProperty(value);\n    if (this.isDisabled !== newDisabledState) {\n      this.isDisabled = newDisabledState;\n      this.changeDetector.markForCheck();\n    }\n  }\n\n  @Input()\n  get required(): boolean {\n    return this.isRequired || (this.radioGroup && this.radioGroup.required);\n  }\n  set required(value: boolean) {\n    this.isRequired = coerceBooleanProperty(value);\n  }\n\n  @Output() readonly change = new EventEmitter<RadioChange>();\n\n  radioGroup: RadioGroupDirective;\n\n  private isLarge = false;\n  private isChecked = false;\n  private isDisabled: boolean;\n  private isRequired: boolean;\n  private innerValue: any = null;\n  private innerLabelPosition: 'before' | 'after' | 'below';\n  private removeUniqueSelectionListener: () => void;\n\n  constructor(\n    @Optional() radioGroup: RadioGroupDirective,\n    private changeDetector: ChangeDetectorRef,\n    private radioDispatcher: UniqueSelectionDispatcher\n  ) {\n    this.radioGroup = radioGroup;\n    this.removeUniqueSelectionListener = radioDispatcher.listen((id: string, name: string) => {\n      if (id !== this.id && name === this.name) {\n        this.checked = false;\n      }\n    });\n  }\n\n  ngOnInit() {\n    if (this.radioGroup) {\n      this.checked = this.radioGroup.value === this.innerValue;\n      this.name = this.radioGroup.name;\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.removeUniqueSelectionListener != null) {\n      this.removeUniqueSelectionListener();\n    }\n  }\n\n  onInputClick(event: Event) {\n    event.stopPropagation();\n  }\n\n  onInputChange(event: Event) {\n    event.stopPropagation();\n\n    if (!this.disabled) {\n      const groupValueChanged = this.radioGroup && this.value !== this.radioGroup.value;\n      this.checked = true;\n      this.emitChangeEvent();\n\n      if (this.radioGroup) {\n        if (typeof this.radioGroup?.controlValueAccessorChangeFn === 'function') {\n          this.radioGroup?.controlValueAccessorChangeFn(this.value);\n        }\n\n        if (groupValueChanged) {\n          this.radioGroup.emitChangeEvent();\n        }\n      }\n    }\n  }\n\n  markForCheck() {\n    this.changeDetector.markForCheck();\n  }\n\n  private emitChangeEvent(): void {\n    this.change.emit(new RadioChange(this, this.innerValue));\n  }\n}\n","<label\n  [attr.for]=\"inputId\"\n  [ngClass]=\"{\n    'fwe-radio': true,\n    'fwe-radio-label-below': labelPosition == 'below',\n    'fwe-radio-label-before': labelPosition == 'before',\n    'fwe-radio-lg': large\n  }\"\n>\n  <input\n    type=\"radio\"\n    [id]=\"inputId\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    [attr.value]=\"value\"\n    [required]=\"required\"\n    (change)=\"onInputChange($event)\"\n    (click)=\"onInputClick($event)\"\n  />\n  <div class=\"fwe-radio-checkmark\"></div>\n  <div class=\"fwe-radio-label-content\">\n    <ng-content></ng-content>\n  </div>\n</label>\n"]}

package/esm2020/lib/forms/segment/segment-control/segment-control.component.mjs

@@ -0,0 +1,57 @@
+import { Component, Input, ViewChild, TemplateRef, ChangeDetectionStrategy, Output, EventEmitter, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class SegmentControlComponent {
+    constructor() {
+        this.change = new EventEmitter();
+    }
+    ngOnInit() {
+        this.id = (Math.random() * Date.now()).toString().replace('.', '-');
+        this.viewMode = 'text';
+    }
+    ngOnChanges(changes) {
+        if (null != changes.icon && null != changes.icon.currentValue) {
+            const prefix = 'fwe-icon-';
+            let icon = changes.icon.currentValue;
+            if (icon.indexOf(prefix) === -1) {
+                icon = `${prefix}${icon}`;
+            }
+            this.icon = icon;
+        }
+        if (null != changes.iconOnly && null != changes.iconOnly.currentValue) {
+            this.viewMode = changes.iconOnly.currentValue === true ? 'icon' : 'icon-text';
+        }
+    }
+    ngAfterViewInit() {
+        this.view = this.tpl.createEmbeddedView(null);
+    }
+    onChange(event) {
+        this.change.emit(event.target.value);
+    }
+}
+SegmentControlComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SegmentControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SegmentControlComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: SegmentControlComponent, selector: "fng-segment-control", inputs: { name: "name", value: "value", label: "label", icon: "icon", iconOnly: "iconOnly", checked: "checked", disabled: "disabled" }, outputs: { change: "change" }, viewQueries: [{ propertyName: "tpl", first: true, predicate: ["tpl"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ng-template #tpl>\n  <input\n    (change)=\"onChange($event)\"\n    class=\"fwe-segment-input\"\n    type=\"radio\"\n    [id]=\"id\"\n    [name]=\"name\"\n    [value]=\"value\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n  />\n  <label class=\"fwe-segment-label\" [for]=\"id\">\n    <ng-container [ngSwitch]=\"viewMode\">\n      <ng-container *ngSwitchCase=\"'icon'\">\n        <span class=\"fwe-sr-only\">{{ label }}</span>\n        <i aria-hidden=\"true\" class=\"fwe-icon\" [ngClass]=\"icon\"></i>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"'text'\">\n        {{ label }}\n      </ng-container>\n      <ng-container *ngSwitchCase=\"'icon-text'\"> <i aria-hidden=\"true\" class=\"fwe-icon\" [ngClass]=\"icon\"></i>{{ label }} </ng-container>\n    </ng-container>\n  </label>\n</ng-template>\n", styles: [""], directives: [{ type: i1.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i1.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: SegmentControlComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fng-segment-control', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<ng-template #tpl>\n  <input\n    (change)=\"onChange($event)\"\n    class=\"fwe-segment-input\"\n    type=\"radio\"\n    [id]=\"id\"\n    [name]=\"name\"\n    [value]=\"value\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n  />\n  <label class=\"fwe-segment-label\" [for]=\"id\">\n    <ng-container [ngSwitch]=\"viewMode\">\n      <ng-container *ngSwitchCase=\"'icon'\">\n        <span class=\"fwe-sr-only\">{{ label }}</span>\n        <i aria-hidden=\"true\" class=\"fwe-icon\" [ngClass]=\"icon\"></i>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"'text'\">\n        {{ label }}\n      </ng-container>\n      <ng-container *ngSwitchCase=\"'icon-text'\"> <i aria-hidden=\"true\" class=\"fwe-icon\" [ngClass]=\"icon\"></i>{{ label }} </ng-container>\n    </ng-container>\n  </label>\n</ng-template>\n", styles: [""] }]
+        }], propDecorators: { name: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], iconOnly: [{
+                type: Input
+            }], checked: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], tpl: [{
+                type: ViewChild,
+                args: ['tpl']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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