design-angular-kit 0.13.0 → 1.0.0-0

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

@@ -0,0 +1,287 @@
+import { Component, Input, Output, EventEmitter, forwardRef, ChangeDetectionStrategy, Directive, ContentChildren, Optional, HostBinding } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "./unique-selection-dispatcher";
+import * as i2 from "../util/focus-mouse.directive";
+let identifier = 0;
+function _coerceBooleanProperty(value) {
+    return value != null && `${value}` !== 'false';
+}
+export class RadioChange {
+    constructor(source, value) {
+        this.source = source;
+        this.value = value;
+    }
+}
+export class RadioGroupDirective {
+    constructor(_changeDetector) {
+        this._changeDetector = _changeDetector;
+        this.role = 'radiogroup';
+        /**
+         * Il valore selezionato per il gruppo. Dovrebbe essere uguale al valore del radio button selezionato se
+         * *esiste* un radio button con un valore corrispondente. Se *non esiste* un radio button corrispondente
+         * questo valore persiste ed è applicato nel caso in cui un nuovo radio button viene aggiunto con il valore
+         * corrispondente.
+         */
+        this._value = null;
+        /** L'attributo HTML name da applicare ai radio button in questo gruppo */
+        this._name = `it-radio-group-${identifier++}`;
+        /** Il radio button attualmente selezionato. */
+        this._selected = null;
+        /** se `value` è stato settato al suo valore iniziale. */
+        this._isInitialized = false;
+        /** Se il radio group è disabilitato. */
+        this._disabled = false;
+        /**
+         * Evento emesso quando il valore del gruppo cambia.
+         * Gli eventi di change sono emessi soltanto quando il valore cambia a causa dell'interazione dell'utente
+         * con il radio button (stesso comportamento di `<input type-"radio">`).
+         */
+        this.change = new EventEmitter();
+        /** Il metodo da chiamare per aggiornare ngModel */
+        this._controlValueAccessorChangeFn = () => { };
+        this.onTouched = () => { };
+    }
+    /** Nome del gruppo di radio button. Tutti i radio button all'interno del gruppo avranno questo nome. */
+    get name() { return this._name; }
+    set name(value) {
+        this._name = value;
+        this._updateRadioButtonNames();
+    }
+    /** Valore del radio button. */
+    get value() { return this._value; }
+    set value(newValue) {
+        if (this._value !== newValue) {
+            this._value = newValue;
+            this._updateSelectedRadioFromValue();
+            this._checkSelectedRadioButton();
+        }
+    }
+    _checkSelectedRadioButton() {
+        if (this._selected && !this._selected.checked) {
+            this._selected.checked = true;
+        }
+    }
+    /** Il radio button selezionato. */
+    get selected() { return this._selected; }
+    set selected(selected) {
+        this._selected = selected;
+        this.value = selected ? selected.value : null;
+        this._checkSelectedRadioButton();
+    }
+    /** Se il gruppo è disabled */
+    get disabled() { return this._disabled; }
+    set disabled(value) {
+        this._disabled = _coerceBooleanProperty(value);
+        this._markRadiosForCheck();
+    }
+    /**
+     * Inizializza le proprietà quando il contenuto dei figliè disponibile.
+     * Questo permette di propagare gli attributi rilevanti ai radio buttons associati.
+     */
+    ngAfterContentInit() {
+        this._isInitialized = true;
+    }
+    _touch() {
+        if (this.onTouched) {
+            this.onTouched();
+        }
+    }
+    _updateRadioButtonNames() {
+        if (this._radios) {
+            this._radios.forEach(radio => {
+                radio.name = this.name;
+            });
+        }
+    }
+    /** Aggiorna il radio button `selected` a seconda del suo _value. */
+    _updateSelectedRadioFromValue() {
+        this._selected = null;
+        this._radios.forEach(radio => {
+            radio.checked = this.value === radio.value;
+            if (radio.checked) {
+                this._selected = radio;
+            }
+        });
+    }
+    /** Invia l'evento change con la selezione corrente e il valore del gruppo. */
+    _emitChangeEvent() {
+        if (this._isInitialized) {
+            this.change.emit(new RadioChange(this._selected, this._value));
+        }
+    }
+    _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;
+    }
+}
+RadioGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: RadioGroupDirective, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+RadioGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.11", type: RadioGroupDirective, selector: "it-radio-group", inputs: { name: "name", value: "value", selected: "selected", disabled: "disabled" }, outputs: { change: "change" }, host: { properties: { "attr.role": "this.role" } }, providers: [{
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => RadioGroupDirective),
+            multi: true
+        }], queries: [{ propertyName: "_radios", predicate: i0.forwardRef(function () { return RadioButtonComponent; }), descendants: true }], exportAs: ["itRadioGroup"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: RadioGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'it-radio-group',
+                    exportAs: 'itRadioGroup',
+                    providers: [{
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => RadioGroupDirective),
+                            multi: true
+                        }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], change: [{
+                type: Output
+            }], _radios: [{
+                type: ContentChildren,
+                args: [forwardRef(() => RadioButtonComponent), { descendants: true }]
+            }], name: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+/**
+ * Un radio button con design bootstrap italia. Supporta tutte le funzionalità di una radio HTML5,
+ * ed espone una API simile. Una `<it-radio-button>` può essere checked, unchecked, o disabled.
+ */
+export class RadioButtonComponent {
+    constructor(radioGroup, _changeDetector, _radioDispatcher) {
+        this._changeDetector = _changeDetector;
+        this._radioDispatcher = _radioDispatcher;
+        this.id = `radio-${identifier++}`;
+        /**
+         * Evento emesso quando il valore `checked` del radio button cambia.
+         */
+        this.change = new EventEmitter();
+        /** Se il radio button è checked. */
+        this._checked = false;
+        /** il valore assegnato al radio button. */
+        this._value = null;
+        this._removeUniqueSelectionListener = () => { };
+        this.radioGroup = radioGroup;
+        this._removeUniqueSelectionListener =
+            _radioDispatcher.listen((id, name) => {
+                if (id !== this.id && name === this.name) {
+                    this.checked = false;
+                }
+            });
+    }
+    /** se il radio button è checked. */
+    get checked() { return this._checked; }
+    set checked(value) {
+        const newCheckedState = _coerceBooleanProperty(value);
+        if (this._checked !== newCheckedState) {
+            this._checked = 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();
+        }
+    }
+    /** Il valore di questo radio button. */
+    get value() { return this._value; }
+    set value(value) {
+        if (this._value !== value) {
+            this._value = value;
+            if (this.radioGroup !== null) {
+                if (!this.checked) {
+                    this.checked = this.radioGroup.value === value;
+                }
+                if (this.checked) {
+                    this.radioGroup.selected = this;
+                }
+            }
+        }
+    }
+    /** Se il radio button è disabled. */
+    get disabled() {
+        return this._disabled || (this.radioGroup !== null && this.radioGroup.disabled);
+    }
+    set disabled(value) {
+        const newDisabledState = !!value;
+        if (this._disabled !== newDisabledState) {
+            this._disabled = newDisabledState;
+            this._changeDetector.markForCheck();
+        }
+    }
+    /**
+     * Segna il radio button come da controllare per la change detection.
+     */
+    _markForCheck() {
+        this._changeDetector.markForCheck();
+    }
+    ngOnInit() {
+        if (this.radioGroup) {
+            // Se il radio button è all'interno di un gruppo, determina se deve essere selezionato
+            this.checked = this.radioGroup.value === this._value;
+            // Copia il `name` del radio group
+            this.name = this.radioGroup.name;
+        }
+    }
+    ngOnDestroy() {
+        this._removeUniqueSelectionListener();
+    }
+    _emitChangeEvent() {
+        this.change.emit(new RadioChange(this, this._value));
+    }
+    _onInputChange(event) {
+        event.stopPropagation();
+        const groupValueChanged = this.radioGroup && this.value !== this.radioGroup.value;
+        this.checked = true;
+        this._emitChangeEvent();
+        if (this.radioGroup) {
+            this.radioGroup._controlValueAccessorChangeFn(this.value);
+            this.radioGroup._touch();
+            if (groupValueChanged) {
+                this.radioGroup._emitChangeEvent();
+            }
+        }
+    }
+}
+RadioButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: RadioButtonComponent, deps: [{ token: RadioGroupDirective, optional: true }, { token: i0.ChangeDetectorRef }, { token: i1.UniqueSelectionDispatcher }], target: i0.ɵɵFactoryTarget.Component });
+RadioButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.11", type: RadioButtonComponent, selector: "it-radio-button", inputs: { name: "name", label: "label", checked: "checked", value: "value", disabled: "disabled" }, outputs: { change: "change" }, exportAs: ["itRadioButton"], ngImport: i0, template: "<div class=\"form-check\">\n  <input type=\"radio\"\n    focusMouse\n    [id]=\"id\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    (change)=\"_onInputChange($event)\">\n  <label\n    [attr.for]=\"id\">{{label}}</label>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i2.FocusMouseDirective, selector: "[focusMouse]", exportAs: ["focusMouse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: RadioButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'it-radio-button', exportAs: 'itRadioButton', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"form-check\">\n  <input type=\"radio\"\n    focusMouse\n    [id]=\"id\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    (change)=\"_onInputChange($event)\">\n  <label\n    [attr.for]=\"id\">{{label}}</label>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: RadioGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef }, { type: i1.UniqueSelectionDispatcher }]; }, propDecorators: { name: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], checked: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio.component.js","sourceRoot":"","sources":["../../../../../projects/design-angular-kit/src/lib/radio/radio.component.ts","../../../../../projects/design-angular-kit/src/lib/radio/radio.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  ChangeDetectorRef,\n  forwardRef,\n  ChangeDetectionStrategy,\n  AfterContentInit,\n  Directive,\n  ContentChildren,\n  QueryList,\n  OnInit,\n  OnDestroy,\n  Optional,\n  HostBinding\n} from '@angular/core';\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\nimport { UniqueSelectionDispatcher } from './unique-selection-dispatcher';\n\nlet identifier = 0;\n\nfunction _coerceBooleanProperty(value: any): boolean {\n  return value != null && `${value}` !== 'false';\n}\n\nexport class RadioChange {\n  constructor(\n    public source: RadioButtonComponent,\n    public value: any\n  ) { }\n}\n\n@Directive({\n  selector: 'it-radio-group', // tslint:disable-line\n  exportAs: 'itRadioGroup',\n  providers: [{\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => RadioGroupDirective),\n    multi: true\n  }]\n})\nexport class RadioGroupDirective implements AfterContentInit, ControlValueAccessor {\n\n  @HostBinding('attr.role') role = 'radiogroup';\n\n  /**\n   * Il valore selezionato per il gruppo. Dovrebbe essere uguale al valore del radio button selezionato se\n   * *esiste* un radio button con un valore corrispondente. Se *non esiste* un radio button corrispondente\n   * questo valore persiste ed è applicato nel caso in cui un nuovo radio button viene aggiunto con il valore\n   * corrispondente.\n   */\n  private _value: any = null;\n\n  /** L'attributo HTML name da applicare ai radio button in questo gruppo */\n  private _name = `it-radio-group-${identifier++}`;\n\n  /** Il radio button attualmente selezionato. */\n  private _selected: RadioButtonComponent | null = null;\n\n  /** se `value` è stato settato al suo valore iniziale. */\n  private _isInitialized = false;\n\n  /** Se il radio group è disabilitato. */\n  private _disabled = false;\n\n\n\n  /**\n   * Evento emesso quando il valore del gruppo cambia.\n   * Gli eventi di change sono emessi soltanto quando il valore cambia a causa dell'interazione dell'utente\n   * con il radio button (stesso comportamento di `<input type-\"radio\">`).\n   */\n  @Output() readonly change: EventEmitter<RadioChange> = new EventEmitter<RadioChange>();\n\n  /** radio buttons figli. */\n  @ContentChildren(forwardRef(() => RadioButtonComponent), { descendants: true }) _radios: QueryList<RadioButtonComponent>; // tslint:disable-line\n\n  /** Il metodo da chiamare per aggiornare ngModel */\n  _controlValueAccessorChangeFn: (value: any) => void = () => { };\n\n  onTouched: () => any = () => { };\n\n  /** Nome del gruppo di radio button. Tutti i radio button all'interno del gruppo avranno questo nome. */\n  @Input()\n  get name(): string { return this._name; }\n  set name(value: string) {\n    this._name = value;\n    this._updateRadioButtonNames();\n  }\n\n  /** Valore del radio button. */\n  @Input()\n  get value(): any { return this._value; }\n  set value(newValue: any) {\n    if (this._value !== newValue) {\n      this._value = newValue;\n\n      this._updateSelectedRadioFromValue();\n      this._checkSelectedRadioButton();\n    }\n  }\n\n  _checkSelectedRadioButton() {\n    if (this._selected && !this._selected.checked) {\n      this._selected.checked = true;\n    }\n  }\n\n  /** Il radio button selezionato. */\n  @Input()\n  get selected() { return this._selected; }\n  set selected(selected: RadioButtonComponent | null) {\n    this._selected = selected;\n    this.value = selected ? selected.value : null;\n    this._checkSelectedRadioButton();\n  }\n\n  /** Se il gruppo è disabled */\n  @Input()\n  get disabled(): boolean { return this._disabled; }\n  set disabled(value) {\n    this._disabled = _coerceBooleanProperty(value);\n    this._markRadiosForCheck();\n  }\n\n  constructor(\n    private _changeDetector: ChangeDetectorRef\n  ) { }\n\n  /**\n   * Inizializza le proprietà quando il contenuto dei figliè disponibile.\n   * Questo permette di propagare gli attributi rilevanti ai radio buttons associati.\n   */\n  ngAfterContentInit(): void {\n    this._isInitialized = true;\n  }\n\n  _touch() {\n    if (this.onTouched) {\n      this.onTouched();\n    }\n  }\n\n  private _updateRadioButtonNames(): void {\n    if (this._radios) {\n      this._radios.forEach(radio => {\n        radio.name = this.name;\n      });\n    }\n  }\n\n  /** Aggiorna il radio button `selected` a seconda del suo _value. */\n  private _updateSelectedRadioFromValue(): void {\n    this._selected = null;\n    this._radios.forEach(radio => {\n      radio.checked = this.value === radio.value;\n      if (radio.checked) {\n        this._selected = radio;\n      }\n    });\n  }\n\n  /** Invia l'evento change con la selezione corrente e il valore del gruppo. */\n  _emitChangeEvent(): void {\n    if (this._isInitialized) {\n      this.change.emit(new RadioChange(this._selected, this._value));\n    }\n  }\n\n  _markRadiosForCheck() {\n    if (this._radios) {\n      this._radios.forEach(radio => radio._markForCheck());\n    }\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    this._changeDetector.markForCheck();\n  }\n\n  registerOnChange(fn: (value: any) => void): void {\n    this._controlValueAccessorChangeFn = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n}\n\n/**\n * Un radio button con design bootstrap italia. Supporta tutte le funzionalità di una radio HTML5,\n * ed espone una API simile. Una `<it-radio-button>` può essere checked, unchecked, o disabled.\n */\n@Component({\n  selector: 'it-radio-button',\n  templateUrl: './radio.component.html',\n  styleUrls: ['./radio.component.scss'],\n  exportAs: 'itRadioButton',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class RadioButtonComponent implements OnInit, OnDestroy {\n\n  id = `radio-${identifier++}`;\n\n  /** Attributo 'name' usato per raggruppare i radio button per un'unica selezione. */\n  @Input() name: string;\n\n  /** L'etichetta delradio button. */\n  @Input()\n  label: string;\n\n  /** se il radio button è checked. */\n  @Input()\n  get checked(): boolean { return this._checked; }\n  set checked(value: boolean) {\n    const newCheckedState = _coerceBooleanProperty(value);\n    if (this._checked !== newCheckedState) {\n      this._checked = 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\n      this._changeDetector.markForCheck();\n    }\n  }\n\n  /** Il valore di questo radio button. */\n  @Input()\n  get value(): any { return this._value; }\n  set value(value: any) {\n    if (this._value !== value) {\n      this._value = 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  /** Se il radio button è disabled. */\n  @Input()\n  get disabled(): boolean {\n    return this._disabled || (this.radioGroup !== null && this.radioGroup.disabled);\n  }\n  set disabled(value: boolean) {\n    const newDisabledState = !!value;\n    if (this._disabled !== newDisabledState) {\n      this._disabled = newDisabledState;\n      this._changeDetector.markForCheck();\n    }\n  }\n\n  /**\n   * Evento emesso quando il valore `checked` del radio button cambia.\n   */\n  @Output() readonly change: EventEmitter<RadioChange> = new EventEmitter<RadioChange>();\n\n  /** Il radio group padre. Può essere presente o meno. */\n  radioGroup: RadioGroupDirective;\n\n  /** Se il radio button è checked. */\n  private _checked = false;\n\n  /** Se il radio button è disabled. */\n  private _disabled: boolean;\n\n  /** il valore assegnato al radio button. */\n  private _value: any = null;\n\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\n    this._removeUniqueSelectionListener =\n      _radioDispatcher.listen((id: string, name: string) => {\n        if (id !== this.id && name === this.name) {\n          this.checked = false;\n        }\n      });\n  }\n\n  /**\n   * Segna il radio button come da controllare per la change detection.\n   */\n  _markForCheck() {\n    this._changeDetector.markForCheck();\n  }\n\n  ngOnInit(): void {\n    if (this.radioGroup) {\n      // Se il radio button è all'interno di un gruppo, determina se deve essere selezionato\n      this.checked = this.radioGroup.value === this._value;\n      // Copia il `name` del radio group\n      this.name = this.radioGroup.name;\n    }\n  }\n\n  ngOnDestroy() {\n    this._removeUniqueSelectionListener();\n  }\n\n  private _emitChangeEvent(): void {\n    this.change.emit(new RadioChange(this, this._value));\n  }\n\n  _onInputChange(event: Event) {\n    event.stopPropagation();\n\n    const groupValueChanged = this.radioGroup && this.value !== this.radioGroup.value;\n    this.checked = true;\n    this._emitChangeEvent();\n\n    if (this.radioGroup) {\n      this.radioGroup._controlValueAccessorChangeFn(this.value);\n      this.radioGroup._touch();\n      if (groupValueChanged) {\n        this.radioGroup._emitChangeEvent();\n      }\n    }\n  }\n}\n","<div class=\"form-check\">\n  <input type=\"radio\"\n    focusMouse\n    [id]=\"id\"\n    [checked]=\"checked\"\n    [disabled]=\"disabled\"\n    [attr.name]=\"name\"\n    (change)=\"_onInputChange($event)\">\n  <label\n    [attr.for]=\"id\">{{label}}</label>\n</div>\n"]}

package/esm2020/lib/radio/unique-selection-dispatcher.mjs

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Class to coordinate unique selection based on name.
+ * Intended to be consumed as an Angular service.
+ * This service is needed because native radio change events are only fired on the item currently
+ * being selected, and we still need to uncheck the previous selection.
+ *
+ * This service does not *store* any IDs and names because they may change at any time, so it is
+ * less error-prone if they are simply passed through when the events occur.
+ */
+export class UniqueSelectionDispatcher {
+    constructor() {
+        this._listeners = [];
+    }
+    /**
+     * Notify other items that selection for the given name has been set.
+     * @param id ID of the item.
+     * @param name Name of the item.
+     */
+    notify(id, name) {
+        for (const listener of this._listeners) {
+            listener(id, name);
+        }
+    }
+    /**
+     * Listen for future changes to item selection.
+     * @return Function used to deregister listener
+     */
+    listen(listener) {
+        this._listeners.push(listener);
+        return () => {
+            this._listeners = this._listeners.filter((registered) => {
+                return listener !== registered;
+            });
+        };
+    }
+    ngOnDestroy() {
+        this._listeners = [];
+    }
+}
+UniqueSelectionDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: UniqueSelectionDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+UniqueSelectionDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: UniqueSelectionDispatcher, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: UniqueSelectionDispatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/tabs/tab-group.component.mjs

@@ -0,0 +1,177 @@
+import { Component, ContentChildren, ViewEncapsulation, ChangeDetectionStrategy, Input, Output, EventEmitter } from '@angular/core';
+import { Subscription, merge } from 'rxjs';
+import { Util } from '../util/util';
+import { ItTabComponent } from './tab.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../util/focus-mouse.directive";
+/** Usato per generare ID univoci per ogni componente tab */
+let nextId = 0;
+/** Un change event emesso ai cambi di selezione. */
+export class TabChangeEvent {
+}
+/**
+* Un componente tab-group con design bootstrap italia. Utilizzabile con il tag `<it-tab-group>`.
+*
+* Supporta al suo interno tab di base `<it-tab>` con una label e un contenuto.
+*/
+export class ItTabGroupComponent {
+    constructor(_changeDetectorRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        /** L'indice del tab che dovrebbe essere selezionato dopo che il contenuto e' stato controllato */
+        this._indexToSelect = 0;
+        /** Subscription all'aggiunta e rimozione di tab. */
+        this._tabsSubscription = Subscription.EMPTY;
+        /** Subscription ai cambiamenti alle label dei tab. */
+        this._tabLabelSubscription = Subscription.EMPTY;
+        this._isPill = false;
+        this._selectedIndex = null;
+        this._dark = false;
+        /** abilita il supporto al data-binding bidirezionale `[(selectedIndex)]` */
+        this.selectedIndexChange = new EventEmitter();
+        /** emesso quando la selezione del tab cambia. */
+        this.selectedTabChange = new EventEmitter(true);
+        this._groupId = nextId++;
+    }
+    /** Se le tab sono formattate come pill. */
+    get pill() { return this._isPill; }
+    set pill(value) {
+        this._isPill = Util.coerceBooleanProperty(value);
+    }
+    /** L'indice della tab attiva. */
+    get selectedIndex() { return this._selectedIndex; }
+    set selectedIndex(value) {
+        this._indexToSelect = Util.coerceNumberProperty(value, null);
+    }
+    /**
+     * Se il tab-group ha un tema scuro
+     */
+    get dark() { return this._dark; }
+    set dark(value) {
+        this._dark = Util.coerceBooleanProperty(value);
+    }
+    /**
+     * Dopo che il contenuto è controllato, il componente conosce i tab che sono stati definiti
+     * e qual è l'indice del tab selezionato.
+     */
+    ngAfterContentChecked() {
+        this.changeTab(this._indexToSelect);
+    }
+    changeTab(newIndex) {
+        // Non fissare `indexToSelect` immediatamente nel setter perchè può accadere che
+        // il numero di tab cambi prima che avvenga la change detection.
+        const indexToSelect = this._indexToSelect = this._clampTabIndex(newIndex);
+        // Se il nuovo tab è disabilitato, non fare niente
+        if (this._tabs && this._tabs.length > 0 && this._tabs.toArray()[indexToSelect].disabled) {
+            return;
+        }
+        if (this._selectedIndex !== indexToSelect && this._selectedIndex != null) {
+            const tabChangeEvent = this._createChangeEvent(indexToSelect);
+            this.selectedTabChange.emit(tabChangeEvent);
+            // Emetto questo valore dopo che è partita la change detection
+            // dal momento che il contenuto controllato potrebbe contenere questa variabile
+            Promise.resolve().then(() => this.selectedIndexChange.emit(indexToSelect));
+        }
+        // Setta la posizione per ogni tab.
+        this._tabs.forEach((tab, index) => {
+            tab.position = index - indexToSelect;
+            tab.isActive = index === indexToSelect;
+        });
+        if (this._selectedIndex !== indexToSelect) {
+            this._selectedIndex = indexToSelect;
+            this._changeDetectorRef.markForCheck();
+        }
+    }
+    ngAfterContentInit() {
+        this._subscribeToTabLabels();
+        // Sottoscrivi al cambiamento nel numero di tab, così da
+        // poter ri-renderizzare il contenuto quando nuove tab vengono aggiunte o rimosse.
+        this._tabsSubscription = this._tabs.changes.subscribe(() => {
+            const indexToSelect = this._clampTabIndex(this._indexToSelect);
+            // Mantieni il tab selezionato precedentemente se un nuovo tab è aggiunto o rimosso e non ci sono
+            // cambiamenti espliciti che selezionino un tab differente.
+            if (indexToSelect === this._selectedIndex) {
+                const tabs = this._tabs.toArray();
+                for (let i = 0; i < tabs.length; i++) {
+                    if (tabs[i].isActive) {
+                        // Assegna `_indexToSelect` e `_selectedIndex` in modo da non emettere un change event
+                        // per evitare al consumer loop infiniti in alcuni casi limite come ad esempio
+                        // se si aggiunge un tab all'interno dell'evento `selectedIndexChange`.
+                        this._indexToSelect = this._selectedIndex = i;
+                        break;
+                    }
+                }
+            }
+            this._subscribeToTabLabels();
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        this._tabsSubscription.unsubscribe();
+        this._tabLabelSubscription.unsubscribe();
+    }
+    _createChangeEvent(index) {
+        const event = new TabChangeEvent;
+        event.index = index;
+        if (this._tabs && this._tabs.length) {
+            event.tab = this._tabs.toArray()[index];
+        }
+        return event;
+    }
+    /**
+     * Sottoscrivi a cambiamenti nelle label dei tab. Necessario perchè l'input per la label è sul TabComponent
+     * mentre il data binding è all'interno di TabGroupComponent. Per fare in modo che il binding sia aggiornato
+     * bisogna sottoscriversi ai cambiamenti e azionare la change detection in maniera manuale.
+     */
+    _subscribeToTabLabels() {
+        if (this._tabLabelSubscription) {
+            this._tabLabelSubscription.unsubscribe();
+        }
+        this._tabLabelSubscription = merge(...this._tabs.map(tab => tab._disableChange), ...this._tabs.map(tab => tab._labelChange)).subscribe(() => {
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    /** fissa l'indice tra 0 e la dimensione dei tab. */
+    _clampTabIndex(index) {
+        return Math.min(this._tabs.length - 1, Math.max(index || 0, 0));
+    }
+    /** ritorna un id univoco per ogni label di tab */
+    _getTabLabelId(i) {
+        return `it-tab-label-${this._groupId}-${i}`;
+    }
+    /** ritorna un id univoco per ogni elemento di contenuto del tab */
+    _getTabContentId(i) {
+        return `it-tab-content-${this._groupId}-${i}`;
+    }
+    /** restituisce il tabIndex del tab. */
+    _getTabIndex(tab, idx) {
+        if (tab.disabled) {
+            return null;
+        }
+        return this.selectedIndex === idx ? 0 : -1;
+    }
+    _handleClick($event, index) {
+        $event.preventDefault();
+        this.changeTab(index);
+    }
+}
+ItTabGroupComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ItTabGroupComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+ItTabGroupComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.11", type: ItTabGroupComponent, selector: "it-tab-group", inputs: { pill: "pill", selectedIndex: "selectedIndex", dark: "dark" }, outputs: { selectedIndexChange: "selectedIndexChange", selectedTabChange: "selectedTabChange" }, queries: [{ propertyName: "_tabs", predicate: ItTabComponent }], exportAs: ["itTabGroup"], ngImport: i0, template: "<ul class=\"nav\" [ngClass]=\"{'nav-dark': dark, 'nav-tabs': !pill, 'nav-pills mb-3': pill}\" role=\"tablist\">\n\n  <li class=\"nav-item\" *ngFor=\"let tab of _tabs; let i = index\">\n    <a\n    focusMouse\n      href=\"#\"\n      role=\"tab\"\n      [attr.aria-controls]=\"_getTabContentId(i)\"\n      [attr.aria-selected]=\"selectedIndex == i\"\n      [attr.aria-label]=\"tab.ariaLabel || null\"\n      [attr.aria-labelledby]=\"(!tab.ariaLabel && tab.ariaLabelledby) ? tab.ariaLabelledby : null\"\n      [ngClass]=\"{ 'nav-link': true, 'active': selectedIndex == i, 'disabled': tab.disabled }\"\n      [id]=\"_getTabLabelId(i)\"\n      (click)=\"_handleClick($event, i)\"\n      >\n      <i *ngIf=\"tab.icon\" class=\"it-ico-lg d-block text-center\" [ngClass]=\"tab.icon\"></i>\n      {{tab.label}}\n    </a>\n  </li>\n</ul>\n<div class=\"tab-content\">\n  <ng-container *ngFor=\"let tab of _tabs; let i = index\">\n    <div\n      [ngClass]=\"{ 'tab-pane p-3': true, 'show active': selectedIndex == i }\"\n      [id]=\"_getTabContentId(i)\"\n      role=\"tabpanel\"\n      [attr.aria-labelledby]=\"_getTabLabelId(i)\">\n      <ng-container *ngTemplateOutlet=\"tab._implicitContent\"></ng-container>\n    </div>\n  </ng-container>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.FocusMouseDirective, selector: "[focusMouse]", exportAs: ["focusMouse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ItTabGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'it-tab-group', exportAs: 'itTabGroup', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ul class=\"nav\" [ngClass]=\"{'nav-dark': dark, 'nav-tabs': !pill, 'nav-pills mb-3': pill}\" role=\"tablist\">\n\n  <li class=\"nav-item\" *ngFor=\"let tab of _tabs; let i = index\">\n    <a\n    focusMouse\n      href=\"#\"\n      role=\"tab\"\n      [attr.aria-controls]=\"_getTabContentId(i)\"\n      [attr.aria-selected]=\"selectedIndex == i\"\n      [attr.aria-label]=\"tab.ariaLabel || null\"\n      [attr.aria-labelledby]=\"(!tab.ariaLabel && tab.ariaLabelledby) ? tab.ariaLabelledby : null\"\n      [ngClass]=\"{ 'nav-link': true, 'active': selectedIndex == i, 'disabled': tab.disabled }\"\n      [id]=\"_getTabLabelId(i)\"\n      (click)=\"_handleClick($event, i)\"\n      >\n      <i *ngIf=\"tab.icon\" class=\"it-ico-lg d-block text-center\" [ngClass]=\"tab.icon\"></i>\n      {{tab.label}}\n    </a>\n  </li>\n</ul>\n<div class=\"tab-content\">\n  <ng-container *ngFor=\"let tab of _tabs; let i = index\">\n    <div\n      [ngClass]=\"{ 'tab-pane p-3': true, 'show active': selectedIndex == i }\"\n      [id]=\"_getTabContentId(i)\"\n      role=\"tabpanel\"\n      [attr.aria-labelledby]=\"_getTabLabelId(i)\">\n      <ng-container *ngTemplateOutlet=\"tab._implicitContent\"></ng-container>\n    </div>\n  </ng-container>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { _tabs: [{
+                type: ContentChildren,
+                args: [ItTabComponent]
+            }], pill: [{
+                type: Input
+            }], selectedIndex: [{
+                type: Input
+            }], dark: [{
+                type: Input
+            }], selectedIndexChange: [{
+                type: Output
+            }], selectedTabChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-group.component.js","sourceRoot":"","sources":["../../../../../projects/design-angular-kit/src/lib/tabs/tab-group.component.ts","../../../../../projects/design-angular-kit/src/lib/tabs/tab-group.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  AfterContentInit,\n  ContentChildren,\n  QueryList,\n  ViewEncapsulation,\n  ChangeDetectionStrategy,\n  Input,\n  Output,\n  EventEmitter,\n  ChangeDetectorRef,\n  AfterContentChecked,\n  OnDestroy\n} from '@angular/core';\nimport { Subscription, merge } from 'rxjs';\nimport { Util } from '../util/util';\nimport { ItTabComponent } from './tab.component';\n\n/** Usato per generare ID univoci per ogni componente tab */\nlet nextId = 0;\n\n/** Un change event emesso ai cambi di selezione. */\nexport class TabChangeEvent {\n  /** Indice del tab selezionato. */\n  index: number;\n  /** Riferimento al tab selezionato. */\n  tab: ItTabComponent;\n}\n\n /**\n * Un componente tab-group con design bootstrap italia. Utilizzabile con il tag `<it-tab-group>`.\n *\n * Supporta al suo interno tab di base `<it-tab>` con una label e un contenuto.\n */\n@Component({\n  selector: 'it-tab-group',\n  exportAs: 'itTabGroup',\n  templateUrl: './tab-group.component.html',\n  styleUrls: ['./tab-group.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ItTabGroupComponent implements AfterContentInit, AfterContentChecked, OnDestroy {\n\n  @ContentChildren(ItTabComponent) _tabs: QueryList<ItTabComponent>;\n\n  /** L'indice del tab che dovrebbe essere selezionato dopo che il contenuto e' stato controllato */\n  private _indexToSelect: number | null = 0;\n\n  /** Subscription all'aggiunta e rimozione di tab. */\n  private _tabsSubscription = Subscription.EMPTY;\n\n  /** Subscription ai cambiamenti alle label dei tab. */\n  private _tabLabelSubscription = Subscription.EMPTY;\n\n  /** Se le tab sono formattate come pill. */\n  @Input()\n  get pill(): boolean { return this._isPill; }\n  set pill(value) {\n    this._isPill = Util.coerceBooleanProperty(value);\n  }\n  private _isPill = false;\n\n\n  /** L'indice della tab attiva. */\n  @Input()\n  get selectedIndex(): number | null { return this._selectedIndex; }\n  set selectedIndex(value: number | null) {\n    this._indexToSelect = Util.coerceNumberProperty(value, null);\n  }\n  private _selectedIndex: number | null = null;\n\n  /**\n   * Se il tab-group ha un tema scuro\n   */\n  @Input()\n  get dark(): boolean { return this._dark; }\n  set dark(value) {\n    this._dark = Util.coerceBooleanProperty(value);\n  }\n  private _dark = false;\n\n  /** abilita il supporto al data-binding bidirezionale `[(selectedIndex)]` */\n  @Output() readonly selectedIndexChange: EventEmitter<number> = new EventEmitter<number>();\n\n  /** emesso quando la selezione del tab cambia. */\n  @Output() readonly selectedTabChange: EventEmitter<TabChangeEvent> =\n      new EventEmitter<TabChangeEvent>(true);\n\n  private _groupId: number;\n\n  constructor(private _changeDetectorRef: ChangeDetectorRef) {\n    this._groupId = nextId++;\n  }\n\n  /**\n   * Dopo che il contenuto è controllato, il componente conosce i tab che sono stati definiti\n   * e qual è l'indice del tab selezionato.\n   */\n  ngAfterContentChecked(): void {\n    this.changeTab(this._indexToSelect);\n  }\n\n  changeTab(newIndex: number): void {\n\n    // Non fissare `indexToSelect` immediatamente nel setter perchè può accadere che\n    // il numero di tab cambi prima che avvenga la change detection.\n    const indexToSelect = this._indexToSelect = this._clampTabIndex(newIndex);\n\n    // Se il nuovo tab è disabilitato, non fare niente\n    if (this._tabs && this._tabs.length > 0 && this._tabs.toArray()[indexToSelect].disabled) {\n      return;\n    }\n\n    if (this._selectedIndex !== indexToSelect && this._selectedIndex != null) {\n      const tabChangeEvent = this._createChangeEvent(indexToSelect);\n      this.selectedTabChange.emit(tabChangeEvent);\n      // Emetto questo valore dopo che è partita la change detection\n      // dal momento che il contenuto controllato potrebbe contenere questa variabile\n      Promise.resolve().then(() => this.selectedIndexChange.emit(indexToSelect));\n    }\n\n    // Setta la posizione per ogni tab.\n    this._tabs.forEach((tab: ItTabComponent, index: number) => {\n      tab.position = index - indexToSelect;\n      tab.isActive = index === indexToSelect;\n    });\n\n    if (this._selectedIndex !== indexToSelect) {\n      this._selectedIndex = indexToSelect;\n      this._changeDetectorRef.markForCheck();\n    }\n  }\n\n  ngAfterContentInit(): void {\n    this._subscribeToTabLabels();\n\n    // Sottoscrivi al cambiamento nel numero di tab, così da\n    // poter ri-renderizzare il contenuto quando nuove tab vengono aggiunte o rimosse.\n    this._tabsSubscription = this._tabs.changes.subscribe(() => {\n      const indexToSelect = this._clampTabIndex(this._indexToSelect);\n\n      // Mantieni il tab selezionato precedentemente se un nuovo tab è aggiunto o rimosso e non ci sono\n      // cambiamenti espliciti che selezionino un tab differente.\n      if (indexToSelect === this._selectedIndex) {\n        const tabs = this._tabs.toArray();\n\n        for (let i = 0; i < tabs.length; i++) {\n          if (tabs[i].isActive) {\n            // Assegna `_indexToSelect` e `_selectedIndex` in modo da non emettere un change event\n            // per evitare al consumer loop infiniti in alcuni casi limite come ad esempio\n            // se si aggiunge un tab all'interno dell'evento `selectedIndexChange`.\n            this._indexToSelect = this._selectedIndex = i;\n            break;\n          }\n        }\n      }\n\n      this._subscribeToTabLabels();\n      this._changeDetectorRef.markForCheck();\n    });\n  }\n\n  ngOnDestroy(): void {\n    this._tabsSubscription.unsubscribe();\n    this._tabLabelSubscription.unsubscribe();\n  }\n\n  private _createChangeEvent(index: number): TabChangeEvent {\n    const event = new TabChangeEvent;\n    event.index = index;\n    if (this._tabs && this._tabs.length) {\n      event.tab = this._tabs.toArray()[index];\n    }\n    return event;\n  }\n\n  /**\n   * Sottoscrivi a cambiamenti nelle label dei tab. Necessario perchè l'input per la label è sul TabComponent\n   * mentre il data binding è all'interno di TabGroupComponent. Per fare in modo che il binding sia aggiornato\n   * bisogna sottoscriversi ai cambiamenti e azionare la change detection in maniera manuale.\n   */\n  private _subscribeToTabLabels() {\n    if (this._tabLabelSubscription) {\n      this._tabLabelSubscription.unsubscribe();\n    }\n\n    this._tabLabelSubscription = merge(\n        ...this._tabs.map(tab => tab._disableChange),\n        ...this._tabs.map(tab => tab._labelChange)).subscribe(() => {\n      this._changeDetectorRef.markForCheck();\n    });\n  }\n\n  /** fissa l'indice tra 0 e la dimensione dei tab. */\n  private _clampTabIndex(index: number | null): number {\n    return Math.min(this._tabs.length - 1, Math.max(index || 0, 0));\n  }\n\n  /** ritorna un id univoco per ogni label di tab */\n  _getTabLabelId(i: number): string {\n    return `it-tab-label-${this._groupId}-${i}`;\n  }\n\n  /** ritorna un id univoco per ogni elemento di contenuto del tab */\n  _getTabContentId(i: number): string {\n    return `it-tab-content-${this._groupId}-${i}`;\n  }\n\n  /** restituisce il tabIndex del tab. */\n  _getTabIndex(tab: ItTabComponent, idx: number): number | null {\n    if (tab.disabled) {\n      return null;\n    }\n    return this.selectedIndex === idx ? 0 : -1;\n  }\n\n  _handleClick($event: Event, index: number): void {\n    $event.preventDefault();\n    this.changeTab(index);\n  }\n\n}\n","<ul class=\"nav\" [ngClass]=\"{'nav-dark': dark, 'nav-tabs': !pill, 'nav-pills mb-3': pill}\" role=\"tablist\">\n\n  <li class=\"nav-item\" *ngFor=\"let tab of _tabs; let i = index\">\n    <a\n    focusMouse\n      href=\"#\"\n      role=\"tab\"\n      [attr.aria-controls]=\"_getTabContentId(i)\"\n      [attr.aria-selected]=\"selectedIndex == i\"\n      [attr.aria-label]=\"tab.ariaLabel || null\"\n      [attr.aria-labelledby]=\"(!tab.ariaLabel && tab.ariaLabelledby) ? tab.ariaLabelledby : null\"\n      [ngClass]=\"{ 'nav-link': true, 'active': selectedIndex == i, 'disabled': tab.disabled }\"\n      [id]=\"_getTabLabelId(i)\"\n      (click)=\"_handleClick($event, i)\"\n      >\n      <i *ngIf=\"tab.icon\" class=\"it-ico-lg d-block text-center\" [ngClass]=\"tab.icon\"></i>\n      {{tab.label}}\n    </a>\n  </li>\n</ul>\n<div class=\"tab-content\">\n  <ng-container *ngFor=\"let tab of _tabs; let i = index\">\n    <div\n      [ngClass]=\"{ 'tab-pane p-3': true, 'show active': selectedIndex == i }\"\n      [id]=\"_getTabContentId(i)\"\n      role=\"tabpanel\"\n      [attr.aria-labelledby]=\"_getTabLabelId(i)\">\n      <ng-container *ngTemplateOutlet=\"tab._implicitContent\"></ng-container>\n    </div>\n  </ng-container>\n</div>\n"]}