design-angular-kit 1.0.0-9 → 1.0.0-prerelease.2

package/esm2022/lib/components/core/table/sort/sort.directive.mjs

@@ -0,0 +1,123 @@
+import { Directive, EventEmitter, Inject, Input, Optional, Output, booleanAttribute, HostBinding } from '@angular/core';
+import { Subject } from 'rxjs';
+import { IT_SORT_DEFAULT_OPTIONS } from "../../../../interfaces/sortable-table";
+import * as i0 from "@angular/core";
+export class ItSortDirective {
+    /** The sort direction of the currently active ItSortable. */
+    get direction() {
+        return this._direction;
+    }
+    set direction(direction) {
+        this._direction = direction;
+    }
+    constructor(_defaultOptions) {
+        this._defaultOptions = _defaultOptions;
+        /**
+          * The direction to set when an MatSortable is initially sorted.
+          * May be overridden by the MatSortable's sort start.
+          */
+        this.start = 'asc';
+        /** Whether the sortable is disabled. */
+        this.sortDisabled = false;
+        /** Event emitted when the user changes either the active sort or sort direction. */
+        this.sortChange = new EventEmitter();
+        this.sortDirectiveClass = 'it-sort';
+        /** Collection of all registered sortables that this directive manages. */
+        this.sortables = new Map();
+        /** Used to notify any child components listening to state changes. */
+        this._stateChanges = new Subject();
+    }
+    /**
+       * Register function to be used by the contained ItSortables. Adds the ItSortable to the
+       * collection of ItSortables.
+       */
+    register(sortable) {
+        this.sortables.set(sortable.id, sortable);
+    }
+    /**
+     * Unregister function to be used by the contained ItSortables. Removes the ItSortable from the
+     * collection of contained ItSortables.
+     */
+    deregister(sortable) {
+        this.sortables.delete(sortable.id);
+    }
+    /** Sets the active sort id and determines the new sort direction. */
+    sort(sortable) {
+        if (this.active != sortable.id) {
+            this.active = sortable.id;
+            this.direction = sortable.start ? sortable.start : this.start;
+        }
+        else {
+            this.direction = this.getNextSortDirection(sortable);
+        }
+        this.sortChange.emit({ active: this.active, direction: this.direction });
+    }
+    /** Returns the next sort direction of the active sortable, checking for potential overrides. */
+    getNextSortDirection(sortable) {
+        if (!sortable) {
+            return undefined;
+        }
+        // Get the sort direction cycle with the potential sortable overrides.
+        const disableClear = sortable?.disableSortClear ?? this.disableSortClear ?? !!this._defaultOptions?.disableClear;
+        let sortDirectionCycle = getSortDirectionCycle(sortable.start || this.start, disableClear);
+        // Get and return the next direction in the cycle
+        let nextDirectionIndex = sortDirectionCycle.indexOf(this.direction) + 1;
+        if (nextDirectionIndex >= sortDirectionCycle.length) {
+            nextDirectionIndex = 0;
+        }
+        return sortDirectionCycle[nextDirectionIndex];
+    }
+    ngOnChanges() {
+        this._stateChanges.next();
+    }
+    ngOnDestroy() {
+        this._stateChanges.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItSortDirective, deps: [{ token: IT_SORT_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "17.1.2", type: ItSortDirective, isStandalone: true, selector: "[itSort]", inputs: { active: ["itSortActive", "active"], start: ["itSortStart", "start"], direction: ["itSortDirection", "direction"], disableSortClear: ["disableSortClear", "disableSortClear", booleanAttribute], sortDisabled: ["sortDisabled", "sortDisabled", booleanAttribute] }, outputs: { sortChange: "sortChange" }, host: { properties: { "class": "this.sortDirectiveClass" } }, exportAs: ["itSort"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItSortDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[itSort]',
+                    exportAs: 'itSort'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [IT_SORT_DEFAULT_OPTIONS]
+                }] }], propDecorators: { active: [{
+                type: Input,
+                args: ['itSortActive']
+            }], start: [{
+                type: Input,
+                args: ['itSortStart']
+            }], direction: [{
+                type: Input,
+                args: ['itSortDirection']
+            }], disableSortClear: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], sortDisabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], sortChange: [{
+                type: Output
+            }], sortDirectiveClass: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+/** Returns the sort direction cycle to use given the provided parameters of order and clear. */
+function getSortDirectionCycle(start, disableClear) {
+    let sortOrder = ['asc', 'desc'];
+    if (start == 'desc') {
+        sortOrder.reverse();
+    }
+    if (!disableClear) {
+        sortOrder.push(undefined);
+    }
+    return sortOrder;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort.directive.js","sourceRoot":"","sources":["../../../../../../../../projects/design-angular-kit/src/lib/components/core/table/sort/sort.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  EventEmitter,\n  Inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  booleanAttribute,\n  HostBinding\n} from '@angular/core';\nimport { Subject } from 'rxjs';\nimport {\n  IT_SORT_DEFAULT_OPTIONS,\n  ItSortable,\n  ItSortDefaultOptions,\n  ItSortEvent,\n  SortDirection\n} from \"../../../../interfaces/sortable-table\";\n\n@Directive({\n  standalone: true,\n  selector: '[itSort]',\n  exportAs: 'itSort'\n})\nexport class ItSortDirective implements OnChanges, OnDestroy {\n\n  /** The id of the most recently sorted ItSortable. */\n  @Input('itSortActive') active?: string;\n\n  /**\n    * The direction to set when an MatSortable is initially sorted.\n    * May be overridden by the MatSortable's sort start.\n    */\n  @Input('itSortStart') start: SortDirection = 'asc';\n\n  /** The sort direction of the currently active ItSortable. */\n  @Input('itSortDirection')\n  get direction(): SortDirection {\n    return this._direction;\n  }\n  set direction(direction: SortDirection) {\n    this._direction = direction;\n  }\n  private _direction: SortDirection;\n\n  /**\n   * Whether to disable the user from clearing the sort by finishing the sort direction cycle.\n   * May be overridden by the ItSortable's disable clear input.\n   */\n  @Input({transform: booleanAttribute})\n  disableSortClear?: boolean;\n\n\n  /** Whether the sortable is disabled. */\n  @Input({transform: booleanAttribute})\n  sortDisabled: boolean = false;\n\n  /** Event emitted when the user changes either the active sort or sort direction. */\n  @Output() readonly sortChange: EventEmitter<ItSortEvent> = new EventEmitter<ItSortEvent>();\n\n  @HostBinding('class')\n  public readonly sortDirectiveClass = 'it-sort';\n\n  /** Collection of all registered sortables that this directive manages. */\n  protected sortables = new Map<string, ItSortable>();\n\n  /** Used to notify any child components listening to state changes. */\n  readonly _stateChanges = new Subject<void>();\n\n  constructor(\n    @Optional()\n    @Inject(IT_SORT_DEFAULT_OPTIONS)\n    private _defaultOptions?: ItSortDefaultOptions,\n  ) {\n  }\n\n  /**\n     * Register function to be used by the contained ItSortables. Adds the ItSortable to the\n     * collection of ItSortables.\n     */\n  register(sortable: ItSortable): void {\n    this.sortables.set(sortable.id, sortable);\n  }\n\n  /**\n   * Unregister function to be used by the contained ItSortables. Removes the ItSortable from the\n   * collection of contained ItSortables.\n   */\n  deregister(sortable: ItSortable): void {\n    this.sortables.delete(sortable.id);\n  }\n\n  /** Sets the active sort id and determines the new sort direction. */\n  sort(sortable: ItSortable): void {\n    if (this.active != sortable.id) {\n      this.active = sortable.id;\n      this.direction = sortable.start ? sortable.start : this.start;\n    } else {\n      this.direction = this.getNextSortDirection(sortable);\n    }\n\n    this.sortChange.emit({active: this.active, direction: this.direction});\n  }\n\n\n  /** Returns the next sort direction of the active sortable, checking for potential overrides. */\n  getNextSortDirection(sortable: ItSortable): SortDirection {\n    if (!sortable) {\n      return undefined;\n    }\n\n    // Get the sort direction cycle with the potential sortable overrides.\n    const disableClear =\n      sortable?.disableSortClear ?? this.disableSortClear ?? !!this._defaultOptions?.disableClear;\n    let sortDirectionCycle = getSortDirectionCycle(sortable.start || this.start, disableClear);\n\n    // Get and return the next direction in the cycle\n    let nextDirectionIndex = sortDirectionCycle.indexOf(this.direction) + 1;\n    if (nextDirectionIndex >= sortDirectionCycle.length) {\n      nextDirectionIndex = 0;\n    }\n    return sortDirectionCycle[nextDirectionIndex];\n  }\n\n  ngOnChanges() {\n    this._stateChanges.next();\n  }\n\n  ngOnDestroy() {\n    this._stateChanges.complete();\n  }\n}\n\n\n/** Returns the sort direction cycle to use given the provided parameters of order and clear. */\nfunction getSortDirectionCycle(start: SortDirection, disableClear: boolean): Array<SortDirection|undefined> {\n  let sortOrder: Array<SortDirection> = ['asc', 'desc'];\n  if (start == 'desc') {\n    sortOrder.reverse();\n  }\n  if (!disableClear) {\n    sortOrder.push(undefined);\n  }\n\n  return sortOrder;\n}\n"]}

package/esm2022/lib/components/core/table/table.component.mjs

@@ -0,0 +1,45 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { inputToBoolean } from '../../../utils/coercion';
+import * as i0 from "@angular/core";
+export class ItTableComponent {
+    constructor() {
+        /**
+         * Responsive tables allow you to scroll tables horizontally with ease.
+         * @default responsive
+         */
+        this.responsive = 'responsive';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "17.1.2", type: ItTableComponent, isStandalone: true, selector: "it-table", inputs: { color: "color", headColor: "headColor", alignment: "alignment", striped: ["striped", "striped", inputToBoolean], hover: ["hover", "hover", inputToBoolean], bordered: ["bordered", "bordered", inputToBoolean], borderless: ["borderless", "borderless", inputToBoolean], compact: ["compact", "compact", inputToBoolean], captionTop: ["captionTop", "captionTop", inputToBoolean], responsive: "responsive" }, ngImport: i0, template: "<div [class]=\"responsive ? 'table-' + responsive : undefined\">\n  <table class=\"table{{color ? ' table-' + color : '' }}{{alignment ? ' ' + alignment : '' }}\"\n         [class.table-striped]=\"striped\"\n         [class.table-hover]=\"hover\"\n         [class.table-bordered]=\"bordered\"\n         [class.table-borderless]=\"borderless\"\n         [class.table-sm]=\"compact\"\n         [class.caption-top]=\"captionTop\">\n    <caption>\n      <ng-content select=\"[caption]\"></ng-content>\n    </caption>\n    <thead [class]=\"headColor ? 'table-' + headColor : undefined\">\n    <ng-content select=\"[thead]\"></ng-content>\n    </thead>\n    <tbody>\n    <ng-content select=\"[tbody]\"></ng-content>\n    </tbody>\n    <tfoot>\n    <ng-content select=\"[tfoot]\"></ng-content>\n    </tfoot>\n  </table>\n</div>\n", styles: ["caption:empty{display:none}caption:empty~thead{border-top:none!important}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItTableComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'it-table', changeDetection: ChangeDetectionStrategy.OnPush, imports: [], template: "<div [class]=\"responsive ? 'table-' + responsive : undefined\">\n  <table class=\"table{{color ? ' table-' + color : '' }}{{alignment ? ' ' + alignment : '' }}\"\n         [class.table-striped]=\"striped\"\n         [class.table-hover]=\"hover\"\n         [class.table-bordered]=\"bordered\"\n         [class.table-borderless]=\"borderless\"\n         [class.table-sm]=\"compact\"\n         [class.caption-top]=\"captionTop\">\n    <caption>\n      <ng-content select=\"[caption]\"></ng-content>\n    </caption>\n    <thead [class]=\"headColor ? 'table-' + headColor : undefined\">\n    <ng-content select=\"[thead]\"></ng-content>\n    </thead>\n    <tbody>\n    <ng-content select=\"[tbody]\"></ng-content>\n    </tbody>\n    <tfoot>\n    <ng-content select=\"[tfoot]\"></ng-content>\n    </tfoot>\n  </table>\n</div>\n", styles: ["caption:empty{display:none}caption:empty~thead{border-top:none!important}\n"] }]
+        }], propDecorators: { color: [{
+                type: Input
+            }], headColor: [{
+                type: Input
+            }], alignment: [{
+                type: Input
+            }], striped: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], hover: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], bordered: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], borderless: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], compact: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], captionTop: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], responsive: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/core/table/table.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { ItTableComponent } from './table.component';
+import { ItSortDirective } from './sort/sort.directive';
+import { ItSortHeaderComponent } from './sort/sort-header/sort-header.component';
+import * as i0 from "@angular/core";
+const tableComponents = [ItTableComponent, ItSortDirective, ItSortHeaderComponent];
+export class ItTableModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: ItTableModule, imports: [ItTableComponent, ItSortDirective, ItSortHeaderComponent], exports: [ItTableComponent, ItSortDirective, ItSortHeaderComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItTableModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: tableComponents,
+                    exports: tableComponents,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWFuZ3VsYXIta2l0L3NyYy9saWIvY29tcG9uZW50cy9jb3JlL3RhYmxlL3RhYmxlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQzs7QUFFakYsTUFBTSxlQUFlLEdBQUcsQ0FBQyxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUscUJBQXFCLENBQUMsQ0FBQztBQU1uRixNQUFNLE9BQU8sYUFBYTs4R0FBYixhQUFhOytHQUFiLGFBQWEsWUFORCxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUscUJBQXFCLGFBQXhELGdCQUFnQixFQUFFLGVBQWUsRUFBRSxxQkFBcUI7K0dBTXBFLGFBQWE7OzJGQUFiLGFBQWE7a0JBSnpCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLGVBQWU7b0JBQ3hCLE9BQU8sRUFBRSxlQUFlO2lCQUN6QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJdFRhYmxlQ29tcG9uZW50IH0gZnJvbSAnLi90YWJsZS5jb21wb25lbnQnO1xuaW1wb3J0IHsgSXRTb3J0RGlyZWN0aXZlIH0gZnJvbSAnLi9zb3J0L3NvcnQuZGlyZWN0aXZlJztcbmltcG9ydCB7IEl0U29ydEhlYWRlckNvbXBvbmVudCB9IGZyb20gJy4vc29ydC9zb3J0LWhlYWRlci9zb3J0LWhlYWRlci5jb21wb25lbnQnO1xuXG5jb25zdCB0YWJsZUNvbXBvbmVudHMgPSBbSXRUYWJsZUNvbXBvbmVudCwgSXRTb3J0RGlyZWN0aXZlLCBJdFNvcnRIZWFkZXJDb21wb25lbnRdO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiB0YWJsZUNvbXBvbmVudHMsXG4gIGV4cG9ydHM6IHRhYmxlQ29tcG9uZW50cyxcbn0pXG5leHBvcnQgY2xhc3MgSXRUYWJsZU1vZHVsZSB7fVxuIl19

package/esm2022/lib/components/core/tooltip/tooltip.directive.mjs

@@ -0,0 +1,143 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Tooltip } from 'bootstrap-italia';
+import { inputToBoolean } from '../../../utils/coercion';
+import * as i0 from "@angular/core";
+export class ItTooltipDirective {
+    /**
+     * Define the tooltip title
+     * @param title the tooltip title
+     */
+    set title(title) {
+        if (title) {
+            // this.element.setAttribute("title", title);
+            this.element.setAttribute('data-bs-original-title', title);
+        }
+    }
+    /**
+     * Define the tooltip placement
+     * @param placement
+     */
+    set tooltipPlacement(placement) {
+        this.element.setAttribute('data-bs-placement', placement);
+    }
+    /**
+     * Indicates whether the title contains html
+     * @param html true if contain html
+     */
+    set tooltipHtml(html) {
+        this.element.setAttribute('data-bs-html', html ? 'true' : 'false');
+    }
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        /**
+         * This event fires immediately when the show method is called.
+         */
+        this.showEvent = new EventEmitter();
+        /**
+         * This event is triggered when the tooltip has been made visible to the user (it will wait for the CSS transitions to complete).
+         */
+        this.shownEvent = new EventEmitter();
+        /**
+         * This event fires immediately when the hide method is called.
+         */
+        this.hideEvent = new EventEmitter();
+        /**
+         * This event is raised when the tooltip has finished being hidden from the user (it will wait for the CSS transitions to complete).
+         */
+        this.hiddenEvent = new EventEmitter();
+        /**
+         * This event fires after the show event when the tooltip template has been added to the DOM.
+         */
+        this.insertedEvent = new EventEmitter();
+        this.element = this._elementRef.nativeElement;
+    }
+    ngAfterViewInit() {
+        this.element.setAttribute('data-bs-toggle', 'tooltip');
+        this.tooltip = Tooltip.getOrCreateInstance(this.element);
+        this.element.addEventListener('show.bs.tooltip', event => this.showEvent.emit(event));
+        this.element.addEventListener('shown.bs.tooltip', event => this.shownEvent.emit(event));
+        this.element.addEventListener('hide.bs.tooltip', event => this.hideEvent.emit(event));
+        this.element.addEventListener('hidden.bs.tooltip', event => this.hiddenEvent.emit(event));
+        this.element.addEventListener('inserted.bs.tooltip', event => this.insertedEvent.emit(event));
+    }
+    ngOnDestroy() {
+        this.dispose();
+    }
+    /**
+     * Shows the tooltip of an item.
+     */
+    show() {
+        this.tooltip?.show();
+    }
+    /**
+     * Hide the tooltip of an element.
+     */
+    hide() {
+        this.tooltip?.hide();
+    }
+    /**
+     * Activate / Deactivate the tooltip of an element
+     */
+    toggle() {
+        this.tooltip?.toggle();
+    }
+    /**
+     * Hides and destroys the tooltip of an element.
+     */
+    dispose() {
+        this.tooltip?.dispose();
+    }
+    /**
+     * Gives the tooltip of an element a chance to be shown.
+     */
+    enable() {
+        this.tooltip?.enable();
+    }
+    /**
+     * Removes the ability to show the tooltip of an element.
+     */
+    disable() {
+        this.tooltip?.disable();
+    }
+    /**
+     * Toggles the possibility that the tooltip of an element is shown or hidden.
+     */
+    toggleEnabled() {
+        this.tooltip?.disable();
+    }
+    /**
+     * Updates the position of an element's tooltip.
+     */
+    update() {
+        this.tooltip?.disable();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItTooltipDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "17.1.2", type: ItTooltipDirective, isStandalone: true, selector: "[itTooltip]", inputs: { title: ["itTooltip", "title"], tooltipPlacement: "tooltipPlacement", tooltipHtml: ["tooltipHtml", "tooltipHtml", inputToBoolean] }, outputs: { showEvent: "showEvent", shownEvent: "shownEvent", hideEvent: "hideEvent", hiddenEvent: "hiddenEvent", insertedEvent: "insertedEvent" }, exportAs: ["itTooltip"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[itTooltip]',
+                    exportAs: 'itTooltip'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { title: [{
+                type: Input,
+                args: ['itTooltip']
+            }], tooltipPlacement: [{
+                type: Input
+            }], tooltipHtml: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], showEvent: [{
+                type: Output
+            }], shownEvent: [{
+                type: Output
+            }], hideEvent: [{
+                type: Output
+            }], hiddenEvent: [{
+                type: Output
+            }], insertedEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/core/tooltip/tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, ElementRef, EventEmitter, Input, OnDestroy, Output } from '@angular/core';\nimport { ElementPlacement } from '../../../interfaces/core';\nimport { Tooltip } from 'bootstrap-italia';\nimport { inputToBoolean } from '../../../utils/coercion';\n\n@Directive({\n  standalone: true,\n  selector: '[itTooltip]',\n  exportAs: 'itTooltip'\n})\nexport class ItTooltipDirective implements AfterViewInit, OnDestroy {\n\n  /**\n   * Define the tooltip title\n   * @param title the tooltip title\n   */\n  @Input('itTooltip') set title(title: string | undefined) {\n    if (title) {\n      // this.element.setAttribute(\"title\", title);\n      this.element.setAttribute('data-bs-original-title', title);\n    }\n  }\n\n  /**\n   * Define the tooltip placement\n   * @param placement\n   */\n  @Input() set tooltipPlacement(placement: ElementPlacement) {\n    this.element.setAttribute('data-bs-placement', placement);\n  }\n\n  /**\n   * Indicates whether the title contains html\n   * @param html true if contain html\n   */\n  @Input({ transform: inputToBoolean }) set tooltipHtml(html: boolean) {\n    this.element.setAttribute('data-bs-html', html ? 'true' : 'false');\n  }\n\n  /**\n   * This event fires immediately when the show method is called.\n   */\n  @Output() showEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event is triggered when the tooltip has been made visible to the user (it will wait for the CSS transitions to complete).\n   */\n  @Output() shownEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event fires immediately when the hide method is called.\n   */\n  @Output() hideEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event is raised when the tooltip has finished being hidden from the user (it will wait for the CSS transitions to complete).\n   */\n  @Output() hiddenEvent: EventEmitter<Event> = new EventEmitter();\n\n  /**\n   * This event fires after the show event when the tooltip template has been added to the DOM.\n   */\n  @Output() insertedEvent: EventEmitter<Event> = new EventEmitter();\n\n  private readonly element: HTMLElement;\n  private tooltip?: Tooltip;\n\n  constructor(\n    private readonly _elementRef: ElementRef\n  ) {\n    this.element = this._elementRef.nativeElement;\n  }\n\n  ngAfterViewInit(): void {\n    this.element.setAttribute('data-bs-toggle', 'tooltip');\n    this.tooltip = Tooltip.getOrCreateInstance(this.element);\n\n    this.element.addEventListener('show.bs.tooltip', event => this.showEvent.emit(event));\n    this.element.addEventListener('shown.bs.tooltip', event => this.shownEvent.emit(event));\n    this.element.addEventListener('hide.bs.tooltip', event => this.hideEvent.emit(event));\n    this.element.addEventListener('hidden.bs.tooltip', event => this.hiddenEvent.emit(event));\n    this.element.addEventListener('inserted.bs.tooltip', event => this.insertedEvent.emit(event));\n  }\n\n  ngOnDestroy(): void {\n    this.dispose();\n  }\n\n  /**\n   * Shows the tooltip of an item.\n   */\n  public show(): void {\n    this.tooltip?.show();\n  }\n\n  /**\n   * Hide the tooltip of an element.\n   */\n  public hide(): void {\n    this.tooltip?.hide();\n  }\n\n  /**\n   * Activate / Deactivate the tooltip of an element\n   */\n  public toggle(): void {\n    this.tooltip?.toggle();\n  }\n\n  /**\n   * Hides and destroys the tooltip of an element.\n   */\n  public dispose(): void {\n    this.tooltip?.dispose();\n  }\n\n  /**\n   * Gives the tooltip of an element a chance to be shown.\n   */\n  public enable(): void {\n    this.tooltip?.enable();\n  }\n\n  /**\n   * Removes the ability to show the tooltip of an element.\n   */\n  public disable(): void {\n    this.tooltip?.disable();\n  }\n\n  /**\n   * Toggles the possibility that the tooltip of an element is shown or hidden.\n   */\n  public toggleEnabled(): void {\n    this.tooltip?.disable();\n  }\n\n  /**\n   * Updates the position of an element's tooltip.\n   */\n  public update(): void {\n    this.tooltip?.disable();\n  }\n\n}\n"]}

package/esm2022/lib/components/form/autocomplete/autocomplete.component.mjs

@@ -0,0 +1,106 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { debounceTime, distinctUntilChanged, map, Observable, of, switchMap } from 'rxjs';
+import { AsyncPipe, NgTemplateOutlet } from '@angular/common';
+import { ReactiveFormsModule } from '@angular/forms';
+import { ItIconComponent } from '../../utils/icon/icon.component';
+import { ItMarkMatchingTextPipe } from '../../../pipes/mark-matching-text.pipe';
+import { ItAbstractFormComponent } from '../../../abstracts/abstract-form.component';
+import { inputToBoolean } from '../../../utils/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class ItAutocompleteComponent extends ItAbstractFormComponent {
+    constructor() {
+        super(...arguments);
+        /**
+         * Time span [ms] has passed without another source emission, to delay data filtering.
+         * Useful when the user is typing multiple letters
+         * @default 300 [ms]
+         */
+        this.debounceTime = 300;
+        /**
+         * The input placeholder
+         */
+        this.placeholder = '';
+        /**
+         * Show the label
+         */
+        this.forceShowLabel = true;
+        /**
+         * Fired when the Autocomplete Item has been selected
+         */
+        this.autocompleteSelectedEvent = new EventEmitter();
+        this.showAutocompletion = false;
+        /** Observable da cui vengono emessi i risultati dell'auto completamento */
+        this.autocompleteResults$ = new Observable();
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.autocompleteResults$ = this.getAutocompleteResults$();
+    }
+    /**
+     * Create the autocomplete list
+     */
+    getAutocompleteResults$() {
+        return this.control.valueChanges.pipe(debounceTime(this.debounceTime), // Delay filter data after time span has passed without another source emission, useful when the user is typing multiple letters
+        distinctUntilChanged(), // Only if searchValue is distinct in comparison to the last value
+        switchMap(searchedValue => {
+            if (!this.autocompleteData) {
+                return of({
+                    searchedValue,
+                    relatedEntries: [],
+                });
+            }
+            const autoCompleteData$ = Array.isArray(this.autocompleteData) ? of(this.autocompleteData) : this.autocompleteData(searchedValue);
+            return autoCompleteData$.pipe(map(autocompleteData => {
+                if (!searchedValue || typeof searchedValue === 'number') {
+                    return { searchedValue, relatedEntries: [] };
+                }
+                const lowercaseValue = searchedValue.toLowerCase();
+                const relatedEntries = autocompleteData.filter(item => item.value?.toLowerCase().includes(lowercaseValue));
+                return { searchedValue, relatedEntries };
+            }));
+        }));
+    }
+    onEntryClick(entry, event) {
+        // Se non è stato definito un link associato all'elemento dell'autocomplete, probabilmente il desiderata
+        // non è effettuare la navigazione al default '#', pertanto in tal caso meglio annullare la navigazione.
+        if (!entry.link) {
+            event.preventDefault();
+        }
+        this.autocompleteSelectedEvent.next(entry);
+        this.control.setValue(entry.value);
+        this.showAutocompletion = false;
+    }
+    autocompleteItemTrackByValueFn(index, item) {
+        return item.value;
+    }
+    onKeyDown() {
+        this.showAutocompletion = true;
+    }
+    get isActiveLabel() {
+        const value = this.control.value;
+        return this.forceShowLabel && (!!value || !!this.placeholder);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItAutocompleteComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: ItAutocompleteComponent, isStandalone: true, selector: "it-autocomplete", inputs: { autocompleteData: "autocompleteData", big: ["big", "big", inputToBoolean], debounceTime: "debounceTime", placeholder: "placeholder", forceShowLabel: ["forceShowLabel", "forceShowLabel", inputToBoolean] }, outputs: { autocompleteSelectedEvent: "autocompleteSelectedEvent" }, usesInheritance: true, ngImport: i0, template: "<div class=\"form-group\" [class.autocomplete-wrapper-big]=\"big\">\n  @if (label) {\n    <label [for]=\"id\" [class.visually-hidden]=\"!isActiveLabel\" [class.active]=\"isActiveLabel\">\n      {{ label }}\n    </label>\n  }\n\n  <input\n    [id]=\"id\"\n    type=\"search\"\n    class=\"autocomplete\"\n    [placeholder]=\"placeholder\"\n    [formControl]=\"control\"\n    [class.is-invalid]=\"isInvalid\"\n    [class.is-valid]=\"isValid\"\n    (blur)=\"markAsTouched()\"\n    (keydown)=\"onKeyDown()\" />\n\n  <span class=\"autocomplete-icon\" aria-hidden=\"true\">\n    <it-icon name=\"search\" size=\"sm\"></it-icon>\n  </span>\n\n  @if (autocompleteResults$ | async; as autocomplete) {\n    <ul class=\"autocomplete-list\" [class.autocomplete-list-show]=\"autocomplete.relatedEntries?.length && showAutocompletion\">\n      @for (entry of autocomplete.relatedEntries; track autocompleteItemTrackByValueFn($index, entry)) {\n        <li>\n          <a [href]=\"entry.link\" (click)=\"onEntryClick(entry, $event)\">\n            @if (entry.avatarSrcPath) {\n              <div class=\"avatar size-sm\">\n                <img [src]=\"entry.avatarSrcPath\" [alt]=\"entry.avatarAltText\" />\n              </div>\n            }\n            @if (entry.icon) {\n              <it-icon [name]=\"entry.icon\" size=\"sm\"></it-icon>\n            }\n            <span class=\"autocomplete-list-text\">\n              <span [innerHTML]=\"entry.value | itMarkMatchingText: autocomplete.searchedValue\"></span>\n              @if (entry.label) {\n                <em>{{ entry.label }}</em>\n              }\n            </span>\n          </a>\n        </li>\n      }\n    </ul>\n  }\n\n  @if (isInvalid) {\n    <div class=\"form-feedback just-validate-error-label\" [id]=\"id + '-error'\">\n      <div #customError>\n        <ng-content select=\"[error]\"></ng-content>\n      </div>\n      @if (!customError.hasChildNodes()) {\n        {{ invalidMessage | async }}\n      }\n    </div>\n  }\n</div>\n", dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "component", type: ItIconComponent, selector: "it-icon", inputs: ["name", "size", "color", "padded", "svgClass", "labelWaria"] }, { kind: "pipe", type: ItMarkMatchingTextPipe, name: "itMarkMatchingText" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItAutocompleteComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'it-autocomplete', imports: [AsyncPipe, ItIconComponent, ItMarkMatchingTextPipe, NgTemplateOutlet, ReactiveFormsModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"form-group\" [class.autocomplete-wrapper-big]=\"big\">\n  @if (label) {\n    <label [for]=\"id\" [class.visually-hidden]=\"!isActiveLabel\" [class.active]=\"isActiveLabel\">\n      {{ label }}\n    </label>\n  }\n\n  <input\n    [id]=\"id\"\n    type=\"search\"\n    class=\"autocomplete\"\n    [placeholder]=\"placeholder\"\n    [formControl]=\"control\"\n    [class.is-invalid]=\"isInvalid\"\n    [class.is-valid]=\"isValid\"\n    (blur)=\"markAsTouched()\"\n    (keydown)=\"onKeyDown()\" />\n\n  <span class=\"autocomplete-icon\" aria-hidden=\"true\">\n    <it-icon name=\"search\" size=\"sm\"></it-icon>\n  </span>\n\n  @if (autocompleteResults$ | async; as autocomplete) {\n    <ul class=\"autocomplete-list\" [class.autocomplete-list-show]=\"autocomplete.relatedEntries?.length && showAutocompletion\">\n      @for (entry of autocomplete.relatedEntries; track autocompleteItemTrackByValueFn($index, entry)) {\n        <li>\n          <a [href]=\"entry.link\" (click)=\"onEntryClick(entry, $event)\">\n            @if (entry.avatarSrcPath) {\n              <div class=\"avatar size-sm\">\n                <img [src]=\"entry.avatarSrcPath\" [alt]=\"entry.avatarAltText\" />\n              </div>\n            }\n            @if (entry.icon) {\n              <it-icon [name]=\"entry.icon\" size=\"sm\"></it-icon>\n            }\n            <span class=\"autocomplete-list-text\">\n              <span [innerHTML]=\"entry.value | itMarkMatchingText: autocomplete.searchedValue\"></span>\n              @if (entry.label) {\n                <em>{{ entry.label }}</em>\n              }\n            </span>\n          </a>\n        </li>\n      }\n    </ul>\n  }\n\n  @if (isInvalid) {\n    <div class=\"form-feedback just-validate-error-label\" [id]=\"id + '-error'\">\n      <div #customError>\n        <ng-content select=\"[error]\"></ng-content>\n      </div>\n      @if (!customError.hasChildNodes()) {\n        {{ invalidMessage | async }}\n      }\n    </div>\n  }\n</div>\n" }]
+        }], propDecorators: { autocompleteData: [{
+                type: Input,
+                args: [{ required: true }]
+            }], big: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], debounceTime: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], forceShowLabel: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], autocompleteSelectedEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete.component.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/form/autocomplete/autocomplete.component.ts","../../../../../../../projects/design-angular-kit/src/lib/components/form/autocomplete/autocomplete.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { debounceTime, distinctUntilChanged, map, Observable, of, switchMap } from 'rxjs';\nimport { AsyncPipe, NgTemplateOutlet } from '@angular/common';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { ItIconComponent } from '../../utils/icon/icon.component';\nimport { ItMarkMatchingTextPipe } from '../../../pipes/mark-matching-text.pipe';\nimport { ItAbstractFormComponent } from '../../../abstracts/abstract-form.component';\nimport { AutocompleteItem } from '../../../interfaces/form';\nimport { inputToBoolean } from '../../../utils/coercion';\n\n@Component({\n  standalone: true,\n  selector: 'it-autocomplete',\n  templateUrl: './autocomplete.component.html',\n  imports: [AsyncPipe, ItIconComponent, ItMarkMatchingTextPipe, NgTemplateOutlet, ReactiveFormsModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ItAutocompleteComponent extends ItAbstractFormComponent<string | null | undefined> implements OnInit {\n  /**\n   * Indicates the list of searchable elements on which to base the input autocomplete system\n   * If you need to retrieve items via API, can pass a function of Observable\n   * @default undefined\n   */\n  @Input({ required: true }) autocompleteData!: Array<AutocompleteItem> | ((search?: string | null) => Observable<Array<AutocompleteItem>>);\n\n  /**\n   * To get a large version of Autocomplete\n   */\n  @Input({ transform: inputToBoolean }) big?: boolean;\n\n  /**\n   * Time span [ms] has passed without another source emission, to delay data filtering.\n   * Useful when the user is typing multiple letters\n   * @default 300 [ms]\n   */\n  @Input() debounceTime = 300;\n\n  /**\n   * The input placeholder\n   */\n  @Input() placeholder = '';\n\n  /**\n   * Show the label\n   */\n  @Input({ transform: inputToBoolean }) forceShowLabel: boolean = true;\n\n  /**\n   * Fired when the Autocomplete Item has been selected\n   */\n  @Output() autocompleteSelectedEvent: EventEmitter<AutocompleteItem> = new EventEmitter();\n\n  protected showAutocompletion = false;\n\n  /** Observable da cui vengono emessi i risultati dell'auto completamento */\n  protected autocompleteResults$: Observable<{\n    searchedValue: string | undefined | null;\n    relatedEntries: Array<AutocompleteItem>;\n  }> = new Observable();\n\n  override ngOnInit() {\n    super.ngOnInit();\n    this.autocompleteResults$ = this.getAutocompleteResults$();\n  }\n\n  /**\n   * Create the autocomplete list\n   */\n  private getAutocompleteResults$(): Observable<{\n    searchedValue: string | null | undefined;\n    relatedEntries: Array<AutocompleteItem>;\n  }> {\n    return this.control.valueChanges.pipe(\n      debounceTime(this.debounceTime), // Delay filter data after time span has passed without another source emission, useful when the user is typing multiple letters\n      distinctUntilChanged(), // Only if searchValue is distinct in comparison to the last value\n      switchMap(searchedValue => {\n        if (!this.autocompleteData) {\n          return of({\n            searchedValue,\n            relatedEntries: <Array<AutocompleteItem>>[],\n          });\n        }\n\n        const autoCompleteData$ = Array.isArray(this.autocompleteData) ? of(this.autocompleteData) : this.autocompleteData(searchedValue);\n        return autoCompleteData$.pipe(\n          map(autocompleteData => {\n            if (!searchedValue || typeof searchedValue === 'number') {\n              return { searchedValue, relatedEntries: [] };\n            }\n\n            const lowercaseValue = searchedValue.toLowerCase();\n            const relatedEntries = autocompleteData.filter(item => item.value?.toLowerCase().includes(lowercaseValue));\n\n            return { searchedValue, relatedEntries };\n          })\n        );\n      })\n    );\n  }\n\n  protected onEntryClick(entry: AutocompleteItem, event: Event) {\n    // Se non è stato definito un link associato all'elemento dell'autocomplete, probabilmente il desiderata\n    // non è effettuare la navigazione al default '#', pertanto in tal caso meglio annullare la navigazione.\n    if (!entry.link) {\n      event.preventDefault();\n    }\n\n    this.autocompleteSelectedEvent.next(entry);\n    this.control.setValue(entry.value);\n    this.showAutocompletion = false;\n  }\n\n  protected autocompleteItemTrackByValueFn(index: number, item: AutocompleteItem) {\n    return item.value;\n  }\n\n  protected onKeyDown() {\n    this.showAutocompletion = true;\n  }\n\n  protected get isActiveLabel(): boolean {\n    const value = this.control.value;\n    return this.forceShowLabel && (!!value || !!this.placeholder);\n  }\n}\n","<div class=\"form-group\" [class.autocomplete-wrapper-big]=\"big\">\n  @if (label) {\n    <label [for]=\"id\" [class.visually-hidden]=\"!isActiveLabel\" [class.active]=\"isActiveLabel\">\n      {{ label }}\n    </label>\n  }\n\n  <input\n    [id]=\"id\"\n    type=\"search\"\n    class=\"autocomplete\"\n    [placeholder]=\"placeholder\"\n    [formControl]=\"control\"\n    [class.is-invalid]=\"isInvalid\"\n    [class.is-valid]=\"isValid\"\n    (blur)=\"markAsTouched()\"\n    (keydown)=\"onKeyDown()\" />\n\n  <span class=\"autocomplete-icon\" aria-hidden=\"true\">\n    <it-icon name=\"search\" size=\"sm\"></it-icon>\n  </span>\n\n  @if (autocompleteResults$ | async; as autocomplete) {\n    <ul class=\"autocomplete-list\" [class.autocomplete-list-show]=\"autocomplete.relatedEntries?.length && showAutocompletion\">\n      @for (entry of autocomplete.relatedEntries; track autocompleteItemTrackByValueFn($index, entry)) {\n        <li>\n          <a [href]=\"entry.link\" (click)=\"onEntryClick(entry, $event)\">\n            @if (entry.avatarSrcPath) {\n              <div class=\"avatar size-sm\">\n                <img [src]=\"entry.avatarSrcPath\" [alt]=\"entry.avatarAltText\" />\n              </div>\n            }\n            @if (entry.icon) {\n              <it-icon [name]=\"entry.icon\" size=\"sm\"></it-icon>\n            }\n            <span class=\"autocomplete-list-text\">\n              <span [innerHTML]=\"entry.value | itMarkMatchingText: autocomplete.searchedValue\"></span>\n              @if (entry.label) {\n                <em>{{ entry.label }}</em>\n              }\n            </span>\n          </a>\n        </li>\n      }\n    </ul>\n  }\n\n  @if (isInvalid) {\n    <div class=\"form-feedback just-validate-error-label\" [id]=\"id + '-error'\">\n      <div #customError>\n        <ng-content select=\"[error]\"></ng-content>\n      </div>\n      @if (!customError.hasChildNodes()) {\n        {{ invalidMessage | async }}\n      }\n    </div>\n  }\n</div>\n"]}

package/esm2022/lib/components/form/checkbox/checkbox.component.mjs

@@ -0,0 +1,48 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { ItAbstractFormComponent } from '../../../abstracts/abstract-form.component';
+import { AsyncPipe, NgTemplateOutlet } from '@angular/common';
+import { ReactiveFormsModule } from '@angular/forms';
+import { inputToBoolean } from '../../../utils/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class ItCheckboxComponent extends ItAbstractFormComponent {
+    ngOnInit() {
+        super.ngOnInit();
+        this.markAsChecked();
+    }
+    ngOnChanges(changes) {
+        if (changes['checked']) {
+            this.markAsChecked();
+        }
+    }
+    markAsChecked() {
+        if (this.control.value || this.checked === undefined) {
+            return;
+        }
+        const value = this.checked;
+        this.writeValue(value);
+        return this.onChange(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItCheckboxComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: ItCheckboxComponent, isStandalone: true, selector: "it-checkbox", inputs: { toggle: ["toggle", "toggle", inputToBoolean], inline: ["inline", "inline", inputToBoolean], group: ["group", "group", inputToBoolean], checked: ["checked", "checked", inputToBoolean], indeterminate: ["indeterminate", "indeterminate", inputToBoolean] }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ng-container>\n  <div class=\"form-check\" [class.form-check-group]=\"group\" [class.form-check-inline]=\"inline\">\n    @if (toggle) {\n      <div class=\"toggles\">\n        <label [for]=\"id\">\n          <ng-container *ngTemplateOutlet=\"htmlLabel\"></ng-container>\n          <input\n            [id]=\"id\"\n            type=\"checkbox\"\n            [formControl]=\"control\"\n            [attr.aria-describedby]=\"id + '-help'\"\n            (click)=\"$event.stopPropagation()\" />\n          <span class=\"lever\"></span>\n        </label>\n      </div>\n    } @else {\n      <input\n        [id]=\"id\"\n        type=\"checkbox\"\n        class=\"form-check-input\"\n        [class.is-invalid]=\"isInvalid\"\n        [class.is-valid]=\"isValid\"\n        [class.semi-checked]=\"indeterminate\"\n        [formControl]=\"control\"\n        [attr.aria-describedby]=\"id + '-help'\"\n        (click)=\"$event.stopPropagation()\" />\n      <label class=\"form-check-label\" [for]=\"id\">\n        <ng-container *ngTemplateOutlet=\"htmlLabel\"></ng-container>\n      </label>\n    }\n\n    @if (group) {\n      <small [id]=\"id + '-help'\" class=\"form-text\">\n        <ng-content></ng-content>\n      </small>\n    }\n\n    @if (isInvalid && group) {\n      <div class=\"form-feedback just-validate-error-label\" [id]=\"id + '-error'\">\n        <ng-container *ngTemplateOutlet=\"error\"></ng-container>\n      </div>\n    }\n  </div>\n\n  @if (isInvalid && !group) {\n    <div class=\"form-feedback just-validate-error-label\" [id]=\"id + '-error'\">\n      <ng-container *ngTemplateOutlet=\"error\"></ng-container>\n    </div>\n  }\n</ng-container>\n\n<ng-template #error>\n  <div #customError>\n    <ng-content select=\"[error]\"></ng-content>\n  </div>\n  @if (!customError.hasChildNodes()) {\n    {{ invalidMessage | async }}\n  }\n</ng-template>\n\n<ng-template #htmlLabel>\n  <div #customLabel>\n    <ng-content select=\"[label]\"></ng-content>\n  </div>\n  @if (!customLabel.hasChildNodes()) {\n    {{ label }}\n  }\n</ng-template>\n", dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ItCheckboxComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'it-checkbox', changeDetection: ChangeDetectionStrategy.OnPush, imports: [NgTemplateOutlet, ReactiveFormsModule, AsyncPipe], template: "<ng-container>\n  <div class=\"form-check\" [class.form-check-group]=\"group\" [class.form-check-inline]=\"inline\">\n    @if (toggle) {\n      <div class=\"toggles\">\n        <label [for]=\"id\">\n          <ng-container *ngTemplateOutlet=\"htmlLabel\"></ng-container>\n          <input\n            [id]=\"id\"\n            type=\"checkbox\"\n            [formControl]=\"control\"\n            [attr.aria-describedby]=\"id + '-help'\"\n            (click)=\"$event.stopPropagation()\" />\n          <span class=\"lever\"></span>\n        </label>\n      </div>\n    } @else {\n      <input\n        [id]=\"id\"\n        type=\"checkbox\"\n        class=\"form-check-input\"\n        [class.is-invalid]=\"isInvalid\"\n        [class.is-valid]=\"isValid\"\n        [class.semi-checked]=\"indeterminate\"\n        [formControl]=\"control\"\n        [attr.aria-describedby]=\"id + '-help'\"\n        (click)=\"$event.stopPropagation()\" />\n      <label class=\"form-check-label\" [for]=\"id\">\n        <ng-container *ngTemplateOutlet=\"htmlLabel\"></ng-container>\n      </label>\n    }\n\n    @if (group) {\n      <small [id]=\"id + '-help'\" class=\"form-text\">\n        <ng-content></ng-content>\n      </small>\n    }\n\n    @if (isInvalid && group) {\n      <div class=\"form-feedback just-validate-error-label\" [id]=\"id + '-error'\">\n        <ng-container *ngTemplateOutlet=\"error\"></ng-container>\n      </div>\n    }\n  </div>\n\n  @if (isInvalid && !group) {\n    <div class=\"form-feedback just-validate-error-label\" [id]=\"id + '-error'\">\n      <ng-container *ngTemplateOutlet=\"error\"></ng-container>\n    </div>\n  }\n</ng-container>\n\n<ng-template #error>\n  <div #customError>\n    <ng-content select=\"[error]\"></ng-content>\n  </div>\n  @if (!customError.hasChildNodes()) {\n    {{ invalidMessage | async }}\n  }\n</ng-template>\n\n<ng-template #htmlLabel>\n  <div #customLabel>\n    <ng-content select=\"[label]\"></ng-content>\n  </div>\n  @if (!customLabel.hasChildNodes()) {\n    {{ label }}\n  }\n</ng-template>\n" }]
+        }], propDecorators: { toggle: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], inline: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], group: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], checked: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], indeterminate: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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