design-angular-kit 1.2.1 → 1.2.2

package/esm2022/lib/components/form/transfer/transfer-list/transfer-list.component.mjs

@@ -0,0 +1,72 @@
+import { AsyncPipe, TitleCasePipe } from '@angular/common';
+import { ChangeDetectionStrategy, Component, HostAttributeToken, inject, ViewChild } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { combineLatest, distinctUntilChanged, map, shareReplay, skip, startWith, tap } from 'rxjs';
+import { ItAbstractComponent } from '../../../../abstracts/abstract.component';
+import { TranslateModule } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../store/transfer.store";
+import * as i2 from "@ngx-translate/core";
+export class ItTransferListComponent extends ItAbstractComponent {
+    constructor(store) {
+        super();
+        this.store = store;
+        /**
+         * Widget title
+         */
+        this.title = inject(new HostAttributeToken('title'), { optional: true });
+        this.sourceType = inject(new HostAttributeToken('sourceType'), { optional: true });
+        this.items = this.store.selectItems(this.sourceType).pipe(distinctUntilChanged(), shareReplay());
+        this.selected = this.store.selectSelectedItems(this.sourceType).pipe(distinctUntilChanged(), shareReplay());
+        this.numberOfItems$ = this.items.pipe(map(items => ({ length: items.length })), startWith({ length: 0 }));
+        this.selectAllDisabled = this.items.pipe(map(items => items.length === 0));
+        /**
+         * Items of the list
+         * @default []
+         */
+        this.items$ = combineLatest([this.items, this.selected]).pipe(map(([items, selected]) => items.map(item => {
+            item.selected = selected.has(item);
+            return item;
+        })));
+        this.instanceId = this.getInstanceId();
+        this.onItemsUpdate();
+    }
+    /**
+     * Checkbox selection click handler
+     */
+    checkboxSelectionHandler(item) {
+        this.store.checkboxSelection(item, this.sourceType);
+    }
+    /**
+     * Checkbox select all selection handler
+     */
+    checkboxSelectAllHandler(event) {
+        const checked = event.target.checked;
+        this.store.selectAllSelection(checked, this.sourceType);
+    }
+    /**
+     * Items update subscription
+     */
+    onItemsUpdate() {
+        this.items
+            .pipe(takeUntilDestroyed(), skip(1), tap(() => {
+            if (this.selectAllCheckboxRef) {
+                this.selectAllCheckboxRef.nativeElement.checked = false;
+            }
+        }))
+            .subscribe();
+    }
+    getInstanceId() {
+        return Math.floor(Math.random() * 100000000).toString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItTransferListComponent, deps: [{ token: i1.TransferStore }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.6", type: ItTransferListComponent, isStandalone: true, selector: "it-transfer-list", viewQueries: [{ propertyName: "selectAllCheckboxRef", first: true, predicate: ["selectAllCheckbox"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"it-transfer-wrapper source\">\n  <div class=\"transfer-header\">\n    <div class=\"form-check\">\n      <input\n        #selectAllCheckbox\n        type=\"checkbox\"\n        id=\"{{ instanceId }}checkbox{{ title }}\"\n        [disabled]=\"selectAllDisabled | async\"\n        (click)=\"checkboxSelectAllHandler($event)\" />\n      <label for=\"{{ instanceId }}checkbox{{ title }}\">\n        <span>\n          @if (numberOfItems$ | async; as numberOfItems) {\n            <span class=\"num\"> {{ numberOfItems.length }}</span>\n            <span> {{ (numberOfItems.length === 1 ? 'it.transfer.item' : 'it.transfer.items') | translate }}</span>\n          }\n        </span>\n        <span class=\"descr\">{{ title | titlecase }}</span>\n      </label>\n    </div>\n    <!-- form check -->\n  </div>\n  <!-- transfer-header -->\n  <div class=\"transfer-scroll\">\n    <div class=\"transfer-group\">\n      @for (item of items$ | async; track item.value) {\n        <div class=\"form-check\">\n          <input\n            type=\"checkbox\"\n            id=\"{{ instanceId }}-{{ item.value }}\"\n            [checked]=\"item.selected\"\n            (click)=\"checkboxSelectionHandler(item)\" />\n          <label for=\"{{ instanceId }}-{{ item.value }}\">\n            <span>\n              <span>{{ item.text }}</span>\n            </span>\n          </label>\n        </div>\n      }\n    </div>\n  </div>\n</div>\n<!-- it-transfer-wrapper -->\n", dependencies: [{ kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "pipe", type: TitleCasePipe, name: "titlecase" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItTransferListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'it-transfer-list', standalone: true, imports: [TranslateModule, AsyncPipe, TitleCasePipe], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"it-transfer-wrapper source\">\n  <div class=\"transfer-header\">\n    <div class=\"form-check\">\n      <input\n        #selectAllCheckbox\n        type=\"checkbox\"\n        id=\"{{ instanceId }}checkbox{{ title }}\"\n        [disabled]=\"selectAllDisabled | async\"\n        (click)=\"checkboxSelectAllHandler($event)\" />\n      <label for=\"{{ instanceId }}checkbox{{ title }}\">\n        <span>\n          @if (numberOfItems$ | async; as numberOfItems) {\n            <span class=\"num\"> {{ numberOfItems.length }}</span>\n            <span> {{ (numberOfItems.length === 1 ? 'it.transfer.item' : 'it.transfer.items') | translate }}</span>\n          }\n        </span>\n        <span class=\"descr\">{{ title | titlecase }}</span>\n      </label>\n    </div>\n    <!-- form check -->\n  </div>\n  <!-- transfer-header -->\n  <div class=\"transfer-scroll\">\n    <div class=\"transfer-group\">\n      @for (item of items$ | async; track item.value) {\n        <div class=\"form-check\">\n          <input\n            type=\"checkbox\"\n            id=\"{{ instanceId }}-{{ item.value }}\"\n            [checked]=\"item.selected\"\n            (click)=\"checkboxSelectionHandler(item)\" />\n          <label for=\"{{ instanceId }}-{{ item.value }}\">\n            <span>\n              <span>{{ item.text }}</span>\n            </span>\n          </label>\n        </div>\n      }\n    </div>\n  </div>\n</div>\n<!-- it-transfer-wrapper -->\n" }]
+        }], ctorParameters: () => [{ type: i1.TransferStore }], propDecorators: { selectAllCheckboxRef: [{
+                type: ViewChild,
+                args: ['selectAllCheckbox']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transfer-list.component.js","sourceRoot":"","sources":["../../../../../../../../projects/design-angular-kit/src/lib/components/form/transfer/transfer-list/transfer-list.component.ts","../../../../../../../../projects/design-angular-kit/src/lib/components/form/transfer/transfer-list/transfer-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, TitleCasePipe } from '@angular/common';\nimport { ChangeDetectionStrategy, Component, ElementRef, HostAttributeToken, inject, ViewChild } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { combineLatest, distinctUntilChanged, map, shareReplay, skip, startWith, tap } from 'rxjs';\nimport { ItAbstractComponent } from '../../../../abstracts/abstract.component';\nimport { TransferStore } from '../store/transfer.store';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { SourceType, TransferItem } from '../transfer.model';\n\ninterface SelectableTransferItem<T> extends TransferItem<T> {\n  selected: boolean;\n}\n\n@Component({\n  selector: 'it-transfer-list',\n  standalone: true,\n  imports: [TranslateModule, AsyncPipe, TitleCasePipe],\n  templateUrl: './transfer-list.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ItTransferListComponent<T> extends ItAbstractComponent {\n  /**\n   * Widget title\n   */\n  readonly title = inject(new HostAttributeToken('title'), { optional: true });\n\n  readonly sourceType = inject(new HostAttributeToken('sourceType'), { optional: true }) as SourceType;\n\n  private readonly items = this.store.selectItems(this.sourceType).pipe(distinctUntilChanged(), shareReplay());\n  private readonly selected = this.store.selectSelectedItems(this.sourceType).pipe(distinctUntilChanged(), shareReplay());\n\n  readonly numberOfItems$ = this.items.pipe(\n    map(items => ({ length: items.length })),\n    startWith({ length: 0 })\n  );\n  readonly selectAllDisabled = this.items.pipe(map(items => items.length === 0));\n  /**\n   * Items of the list\n   * @default []\n   */\n  readonly items$ = combineLatest([this.items, this.selected]).pipe(\n    map(([items, selected]) =>\n      items.map(item => {\n        (item as SelectableTransferItem<T>).selected = selected.has(item);\n        return item as SelectableTransferItem<T>;\n      })\n    )\n  );\n\n  @ViewChild('selectAllCheckbox')\n  selectAllCheckboxRef!: ElementRef<HTMLInputElement>;\n\n  readonly instanceId = this.getInstanceId();\n\n  constructor(private readonly store: TransferStore<T>) {\n    super();\n    this.onItemsUpdate();\n  }\n  /**\n   * Checkbox selection click handler\n   */\n  checkboxSelectionHandler(item: TransferItem<T>) {\n    this.store.checkboxSelection(item, this.sourceType);\n  }\n  /**\n   * Checkbox select all selection handler\n   */\n  checkboxSelectAllHandler(event: Event) {\n    const checked = ((event as PointerEvent).target as HTMLInputElement).checked;\n    this.store.selectAllSelection(checked, this.sourceType);\n  }\n\n  /**\n   * Items update subscription\n   */\n  private onItemsUpdate() {\n    this.items\n      .pipe(\n        takeUntilDestroyed(),\n        skip(1),\n        tap(() => {\n          if (this.selectAllCheckboxRef) {\n            this.selectAllCheckboxRef.nativeElement.checked = false;\n          }\n        })\n      )\n      .subscribe();\n  }\n\n  private getInstanceId() {\n    return Math.floor(Math.random() * 100000000).toString();\n  }\n}\n","<div class=\"it-transfer-wrapper source\">\n  <div class=\"transfer-header\">\n    <div class=\"form-check\">\n      <input\n        #selectAllCheckbox\n        type=\"checkbox\"\n        id=\"{{ instanceId }}checkbox{{ title }}\"\n        [disabled]=\"selectAllDisabled | async\"\n        (click)=\"checkboxSelectAllHandler($event)\" />\n      <label for=\"{{ instanceId }}checkbox{{ title }}\">\n        <span>\n          @if (numberOfItems$ | async; as numberOfItems) {\n            <span class=\"num\"> {{ numberOfItems.length }}</span>\n            <span> {{ (numberOfItems.length === 1 ? 'it.transfer.item' : 'it.transfer.items') | translate }}</span>\n          }\n        </span>\n        <span class=\"descr\">{{ title | titlecase }}</span>\n      </label>\n    </div>\n    <!-- form check -->\n  </div>\n  <!-- transfer-header -->\n  <div class=\"transfer-scroll\">\n    <div class=\"transfer-group\">\n      @for (item of items$ | async; track item.value) {\n        <div class=\"form-check\">\n          <input\n            type=\"checkbox\"\n            id=\"{{ instanceId }}-{{ item.value }}\"\n            [checked]=\"item.selected\"\n            (click)=\"checkboxSelectionHandler(item)\" />\n          <label for=\"{{ instanceId }}-{{ item.value }}\">\n            <span>\n              <span>{{ item.text }}</span>\n            </span>\n          </label>\n        </div>\n      }\n    </div>\n  </div>\n</div>\n<!-- it-transfer-wrapper -->\n"]}

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

@@ -0,0 +1,149 @@
+import { AsyncPipe, NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, DestroyRef, EventEmitter, inject, Input, Optional, Output, Self } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { FormControlName, NgModel, ReactiveFormsModule } from '@angular/forms';
+import { tap } from 'rxjs';
+import { ItAbstractFormComponent } from '../../../abstracts/abstract-form.component';
+import { TransferStore } from './store/transfer.store';
+import { ItTransferListComponent } from './transfer-list/transfer-list.component';
+import { TranslateModule } from '@ngx-translate/core';
+import { ItIconComponent } from '../../utils/icon/icon.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "./store/transfer.store";
+/**
+ * Transfer
+ * @description Component that allows the creation of checkbox lists.
+ */
+export class ItTransferComponent extends ItAbstractFormComponent {
+    constructor(_ngControl, _translateService, store) {
+        super(_translateService, _ngControl);
+        this._ngControl = _ngControl;
+        this._translateService = _translateService;
+        this.store = store;
+        /**
+         * The select options (left side)
+         */
+        this.options = [];
+        /**
+         * The selected options (right side)
+         */
+        this.selected = [];
+        /**
+         * Fired when there is a transfer, a backtransfer or a reset event
+         */
+        this.transferChanges = new EventEmitter();
+        /**
+         * Enable transfer button
+         * @default false
+         */
+        this.transferEnabled = this.store.transferEnabled;
+        /**
+         * Enable backtransfer button
+         * @default false
+         */
+        this.backtransferEnabled = this.store.backtransferEnabled;
+        /**
+         * Enable reset button
+         * @default false
+         */
+        this.resetEnabled = this.store.resetEnabled;
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.storeInit();
+        this.onStoreValueChanged();
+    }
+    /**
+     * Transfer button click handler
+     */
+    transferClickHandler(event) {
+        this.buttonEventHandler(event, () => this.store.transfer());
+    }
+    /**
+     * Transfer button keypress handler
+     */
+    transferKeyPressHandler(event) {
+        this.buttonEventHandler(event, () => this.store.transfer());
+    }
+    /**
+     * Backtransfer button click handler
+     */
+    backtransferClickHandler(event) {
+        this.buttonEventHandler(event, () => this.store.backtransfer());
+    }
+    /**
+     * Backtransfer button keypress handler
+     */
+    backtransferKeyPressHandler(event) {
+        this.buttonEventHandler(event, () => this.store.backtransfer());
+    }
+    /**
+     * Reset button click handler
+     */
+    resetClickHandler(event) {
+        this.buttonEventHandler(event, () => this.store.reset());
+    }
+    /**
+     * Reset button keypress handler
+     */
+    resetKeyPressHandler(event) {
+        this.buttonEventHandler(event, () => this.store.reset());
+    }
+    buttonEventHandler(event, updateStoreCb) {
+        event.preventDefault();
+        updateStoreCb();
+    }
+    storeInit() {
+        let target = [];
+        const ngControl = this._ngControl;
+        const isNgControlDefined = Boolean(this._ngControl);
+        // if ngControl is defined, take values from it. Input() target will be ignored
+        if (isNgControlDefined) {
+            console.debug('ngControl instanceof NgModel:', ngControl instanceof NgModel);
+            console.debug('ngControl instanceof FormControlName:', ngControl instanceof FormControlName);
+            // if ngControl is an ngModel (template-driven form use case), take values from it
+            if (ngControl instanceof NgModel) {
+                console.debug('ngControl instanceof NgModel');
+                const model = ngControl.model;
+                target = Array.isArray(model) ? model : [];
+            }
+            // if ngControl is an FormControlName (reactive form use case), take values from it
+            if (ngControl instanceof FormControlName) {
+                console.debug('ngControl instanceof FormControlName');
+                const model = ngControl.control.value;
+                target = Array.isArray(model) ? model : [];
+            }
+            console.debug('ngControl is defined. Input() target will be ignored');
+        }
+        else if (this.selected && Array.isArray(this.selected)) {
+            target = [...this.selected];
+        }
+        console.debug('target:', this.selected, 'formControl:', this.control.value, 'ngModel:', this._ngControl);
+        this.store.init({ source: [...this.options], target });
+    }
+    onStoreValueChanged() {
+        this.store.valueChanged
+            .pipe(takeUntilDestroyed(this.destroyRef), tap(value => this.writeValue(value)), tap(value => this.onChange(value)), tap(value => this.transferChanges.emit(value)))
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItTransferComponent, deps: [{ token: i1.NgControl, optional: true, self: true }, { token: i2.TranslateService }, { token: i3.TransferStore }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.6", type: ItTransferComponent, isStandalone: true, selector: "it-transfer", inputs: { options: "options", selected: "selected" }, outputs: { transferChanges: "transferChanges" }, providers: [TransferStore], usesInheritance: true, ngImport: i0, template: "<div>\n  @if (label) {\n    <label [for]=\"id\" [class.active]=\"!!control.value\">{{ label }}</label>\n  }\n  <div class=\"row\">\n    <div class=\"col-xs-12 col-md-5\">\n      <it-transfer-list sourceType=\"source\" [title]=\"'it.transfer.source' | translate\"></it-transfer-list>\n    </div>\n    <!-- col -->\n    <div class=\"col-xs-12 col-md-2\">\n      <!-- transfer buttons-->\n      <div class=\"it-transfer-buttons\">\n        <a\n          class=\"transfer\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: transferEnabled | async }\"\n          (click)=\"transferClickHandler($event)\"\n          (keypress)=\"transferKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-move-forward' | translate\">\n          <it-icon name=\"arrow-right\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-move-forward' | translate }}</span>\n        <a\n          class=\"backtransfer\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: backtransferEnabled | async }\"\n          (click)=\"backtransferClickHandler($event)\"\n          (keypress)=\"backtransferKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-move-backward' | translate\">\n          <it-icon name=\"arrow-left\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-move-backward' | translate }}</span>\n        <a\n          class=\"reset\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: resetEnabled | async }\"\n          (click)=\"resetClickHandler($event)\"\n          (keypress)=\"resetKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-reset' | translate\">\n          <it-icon name=\"restore\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-reset' | translate }}</span>\n      </div>\n    </div>\n    <div class=\"col-xs-12 col-md-5\">\n      <it-transfer-list sourceType=\"target\" [title]=\"'it.transfer.target' | translate\"></it-transfer-list>\n    </div>\n  </div>\n</div>\n", dependencies: [{ kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }, { kind: "component", type: ItIconComponent, selector: "it-icon", inputs: ["name", "size", "color", "padded", "svgClass", "title", "labelWaria"] }, { kind: "component", type: ItTransferListComponent, selector: "it-transfer-list" }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItTransferComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'it-transfer', standalone: true, imports: [TranslateModule, ItIconComponent, ItTransferListComponent, NgClass, AsyncPipe, ReactiveFormsModule], providers: [TransferStore], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div>\n  @if (label) {\n    <label [for]=\"id\" [class.active]=\"!!control.value\">{{ label }}</label>\n  }\n  <div class=\"row\">\n    <div class=\"col-xs-12 col-md-5\">\n      <it-transfer-list sourceType=\"source\" [title]=\"'it.transfer.source' | translate\"></it-transfer-list>\n    </div>\n    <!-- col -->\n    <div class=\"col-xs-12 col-md-2\">\n      <!-- transfer buttons-->\n      <div class=\"it-transfer-buttons\">\n        <a\n          class=\"transfer\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: transferEnabled | async }\"\n          (click)=\"transferClickHandler($event)\"\n          (keypress)=\"transferKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-move-forward' | translate\">\n          <it-icon name=\"arrow-right\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-move-forward' | translate }}</span>\n        <a\n          class=\"backtransfer\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: backtransferEnabled | async }\"\n          (click)=\"backtransferClickHandler($event)\"\n          (keypress)=\"backtransferKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-move-backward' | translate\">\n          <it-icon name=\"arrow-left\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-move-backward' | translate }}</span>\n        <a\n          class=\"reset\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: resetEnabled | async }\"\n          (click)=\"resetClickHandler($event)\"\n          (keypress)=\"resetKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-reset' | translate\">\n          <it-icon name=\"restore\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-reset' | translate }}</span>\n      </div>\n    </div>\n    <div class=\"col-xs-12 col-md-5\">\n      <it-transfer-list sourceType=\"target\" [title]=\"'it.transfer.target' | translate\"></it-transfer-list>\n    </div>\n  </div>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }, { type: i2.TranslateService }, { type: i3.TransferStore }], propDecorators: { options: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], transferChanges: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transfer.component.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/form/transfer/transfer.component.ts","../../../../../../../projects/design-angular-kit/src/lib/components/form/transfer/transfer.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAU,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC5I,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAa,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1F,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAElF,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;;;;;AAElE;;;GAGG;AASH,MAAM,OAAO,mBAA6B,SAAQ,uBAA0B;IAgC1E,YAGoB,UAAqB,EACrB,iBAAmC,EACpC,KAAuB;QAExC,KAAK,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;QAJnB,eAAU,GAAV,UAAU,CAAW;QACrB,sBAAiB,GAAjB,iBAAiB,CAAkB;QACpC,UAAK,GAAL,KAAK,CAAkB;QApC1C;;WAEG;QACM,YAAO,GAAG,EAAE,CAAC;QACtB;;WAEG;QACM,aAAQ,GAAG,EAAE,CAAC;QACvB;;WAEG;QACgB,oBAAe,GAAG,IAAI,YAAY,EAAqB,CAAC;QAE3E;;;WAGG;QACM,oBAAe,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;QACtD;;;WAGG;QACM,wBAAmB,GAAG,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC;QAC9D;;;WAGG;QACM,iBAAY,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;QAE/B,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAUjD,CAAC;IAEQ,QAAQ;QACf,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,oBAAoB,CAAC,KAAiB;QACpC,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,CAAC;IACD;;OAEG;IACH,uBAAuB,CAAC,KAAoB;QAC1C,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,CAAC;IACD;;OAEG;IACH,wBAAwB,CAAC,KAAiB;QACxC,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;IAClE,CAAC;IACD;;OAEG;IACH,2BAA2B,CAAC,KAAoB;QAC9C,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;IAClE,CAAC;IACD;;OAEG;IACH,iBAAiB,CAAC,KAAiB;QACjC,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;IAC3D,CAAC;IACD;;OAEG;IACH,oBAAoB,CAAC,KAAoB;QACvC,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;IAC3D,CAAC;IAEO,kBAAkB,CAAC,KAAY,EAAE,aAAyB;QAChE,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,aAAa,EAAE,CAAC;IAClB,CAAC;IAEO,SAAS;QACf,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC;QAClC,MAAM,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAEpD,+EAA+E;QAC/E,IAAI,kBAAkB,EAAE,CAAC;YACvB,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE,SAAS,YAAY,OAAO,CAAC,CAAC;YAC7E,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAE,SAAS,YAAY,eAAe,CAAC,CAAC;YAE7F,kFAAkF;YAClF,IAAI,SAAS,YAAY,OAAO,EAAE,CAAC;gBACjC,OAAO,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC;gBAC9C,MAAM,KAAK,GAAI,SAAqB,CAAC,KAAK,CAAC;gBAC3C,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YAC7C,CAAC;YAED,mFAAmF;YACnF,IAAI,SAAS,YAAY,eAAe,EAAE,CAAC;gBACzC,OAAO,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;gBACtD,MAAM,KAAK,GAAI,SAA6B,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC3D,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YAC7C,CAAC;YAED,OAAO,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;QACxE,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzD,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9B,CAAC;QAED,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACzG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzD,CAAC;IAEO,mBAAmB;QACzB,IAAI,CAAC,KAAK,CAAC,YAAY;aACpB,IAAI,CACH,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,EACnC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,KAAU,CAAC,CAAC,EACzC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAU,CAAC,CAAC,EACvC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAC/C;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;8GApIU,mBAAmB;kGAAnB,mBAAmB,iKAHnB,CAAC,aAAa,CAAC,iDCtB5B,+mEAoDA,2CD/BY,eAAe,4FAAE,eAAe,oIAAE,uBAAuB,6DAAE,OAAO,+EAAE,SAAS,6CAAE,mBAAmB;;2FAIjG,mBAAmB;kBAR/B,SAAS;+BACE,aAAa,cACX,IAAI,WAEP,CAAC,eAAe,EAAE,eAAe,EAAE,uBAAuB,EAAE,OAAO,EAAE,SAAS,EAAE,mBAAmB,CAAC,aAClG,CAAC,aAAa,CAAC,mBACT,uBAAuB,CAAC,MAAM;;0BAmC5C,IAAI;;0BACJ,QAAQ;oGA9BF,OAAO;sBAAf,KAAK;gBAIG,QAAQ;sBAAhB,KAAK;gBAIa,eAAe;sBAAjC,MAAM","sourcesContent":["import { AsyncPipe, NgClass } from '@angular/common';\nimport { ChangeDetectionStrategy, Component, DestroyRef, EventEmitter, inject, Input, OnInit, Optional, Output, Self } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { FormControlName, NgControl, NgModel, ReactiveFormsModule } from '@angular/forms';\nimport { TranslateService } from '@ngx-translate/core';\nimport { tap } from 'rxjs';\nimport { ItAbstractFormComponent } from '../../../abstracts/abstract-form.component';\nimport { TransferStore } from './store/transfer.store';\nimport { ItTransferListComponent } from './transfer-list/transfer-list.component';\nimport { TransferItem } from './transfer.model';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { ItIconComponent } from '../../utils/icon/icon.component';\n\n/**\n * Transfer\n * @description Component that allows the creation of checkbox lists.\n */\n@Component({\n  selector: 'it-transfer',\n  standalone: true,\n  templateUrl: './transfer.component.html',\n  imports: [TranslateModule, ItIconComponent, ItTransferListComponent, NgClass, AsyncPipe, ReactiveFormsModule],\n  providers: [TransferStore],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ItTransferComponent<T = any> extends ItAbstractFormComponent<T> implements OnInit {\n  /**\n   * The select options (left side)\n   */\n  @Input() options = [];\n  /**\n   * The selected options (right side)\n   */\n  @Input() selected = [];\n  /**\n   * Fired when there is a transfer, a backtransfer or a reset event\n   */\n  @Output() readonly transferChanges = new EventEmitter<TransferItem<T>[]>();\n\n  /**\n   * Enable transfer button\n   * @default false\n   */\n  readonly transferEnabled = this.store.transferEnabled;\n  /**\n   * Enable backtransfer button\n   * @default false\n   */\n  readonly backtransferEnabled = this.store.backtransferEnabled;\n  /**\n   * Enable reset button\n   * @default false\n   */\n  readonly resetEnabled = this.store.resetEnabled;\n\n  private readonly destroyRef = inject(DestroyRef);\n\n  constructor(\n    @Self()\n    @Optional()\n    override readonly _ngControl: NgControl,\n    override readonly _translateService: TranslateService,\n    private readonly store: TransferStore<T>\n  ) {\n    super(_translateService, _ngControl);\n  }\n\n  override ngOnInit() {\n    super.ngOnInit();\n    this.storeInit();\n    this.onStoreValueChanged();\n  }\n\n  /**\n   * Transfer button click handler\n   */\n  transferClickHandler(event: MouseEvent) {\n    this.buttonEventHandler(event, () => this.store.transfer());\n  }\n  /**\n   * Transfer button keypress handler\n   */\n  transferKeyPressHandler(event: KeyboardEvent) {\n    this.buttonEventHandler(event, () => this.store.transfer());\n  }\n  /**\n   * Backtransfer button click handler\n   */\n  backtransferClickHandler(event: MouseEvent) {\n    this.buttonEventHandler(event, () => this.store.backtransfer());\n  }\n  /**\n   * Backtransfer button keypress handler\n   */\n  backtransferKeyPressHandler(event: KeyboardEvent) {\n    this.buttonEventHandler(event, () => this.store.backtransfer());\n  }\n  /**\n   * Reset button click handler\n   */\n  resetClickHandler(event: MouseEvent) {\n    this.buttonEventHandler(event, () => this.store.reset());\n  }\n  /**\n   * Reset button keypress handler\n   */\n  resetKeyPressHandler(event: KeyboardEvent) {\n    this.buttonEventHandler(event, () => this.store.reset());\n  }\n\n  private buttonEventHandler(event: Event, updateStoreCb: () => void) {\n    event.preventDefault();\n    updateStoreCb();\n  }\n\n  private storeInit() {\n    let target = [];\n    const ngControl = this._ngControl;\n    const isNgControlDefined = Boolean(this._ngControl);\n\n    // if ngControl is defined, take values from it. Input() target will be ignored\n    if (isNgControlDefined) {\n      console.debug('ngControl instanceof NgModel:', ngControl instanceof NgModel);\n      console.debug('ngControl instanceof FormControlName:', ngControl instanceof FormControlName);\n\n      // if ngControl is an ngModel (template-driven form use case), take values from it\n      if (ngControl instanceof NgModel) {\n        console.debug('ngControl instanceof NgModel');\n        const model = (ngControl as NgModel).model;\n        target = Array.isArray(model) ? model : [];\n      }\n\n      // if ngControl is an FormControlName (reactive form use case), take values from it\n      if (ngControl instanceof FormControlName) {\n        console.debug('ngControl instanceof FormControlName');\n        const model = (ngControl as FormControlName).control.value;\n        target = Array.isArray(model) ? model : [];\n      }\n\n      console.debug('ngControl is defined. Input() target will be ignored');\n    } else if (this.selected && Array.isArray(this.selected)) {\n      target = [...this.selected];\n    }\n\n    console.debug('target:', this.selected, 'formControl:', this.control.value, 'ngModel:', this._ngControl);\n    this.store.init({ source: [...this.options], target });\n  }\n\n  private onStoreValueChanged() {\n    this.store.valueChanged\n      .pipe(\n        takeUntilDestroyed(this.destroyRef),\n        tap(value => this.writeValue(value as T)),\n        tap(value => this.onChange(value as T)),\n        tap(value => this.transferChanges.emit(value))\n      )\n      .subscribe();\n  }\n}\n","<div>\n  @if (label) {\n    <label [for]=\"id\" [class.active]=\"!!control.value\">{{ label }}</label>\n  }\n  <div class=\"row\">\n    <div class=\"col-xs-12 col-md-5\">\n      <it-transfer-list sourceType=\"source\" [title]=\"'it.transfer.source' | translate\"></it-transfer-list>\n    </div>\n    <!-- col -->\n    <div class=\"col-xs-12 col-md-2\">\n      <!-- transfer buttons-->\n      <div class=\"it-transfer-buttons\">\n        <a\n          class=\"transfer\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: transferEnabled | async }\"\n          (click)=\"transferClickHandler($event)\"\n          (keypress)=\"transferKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-move-forward' | translate\">\n          <it-icon name=\"arrow-right\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-move-forward' | translate }}</span>\n        <a\n          class=\"backtransfer\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: backtransferEnabled | async }\"\n          (click)=\"backtransferClickHandler($event)\"\n          (keypress)=\"backtransferKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-move-backward' | translate\">\n          <it-icon name=\"arrow-left\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-move-backward' | translate }}</span>\n        <a\n          class=\"reset\"\n          role=\"button\"\n          href=\"#\"\n          [ngClass]=\"{ active: resetEnabled | async }\"\n          (click)=\"resetClickHandler($event)\"\n          (keypress)=\"resetKeyPressHandler($event)\"\n          [attr.aria-label]=\"'it.transfer.aria-label-reset' | translate\">\n          <it-icon name=\"restore\"></it-icon>\n        </a>\n        <span class=\"visually-hidden\">{{ 'it.transfer.label-reset' | translate }}</span>\n      </div>\n    </div>\n    <div class=\"col-xs-12 col-md-5\">\n      <it-transfer-list sourceType=\"target\" [title]=\"'it.transfer.target' | translate\"></it-transfer-list>\n    </div>\n  </div>\n</div>\n"]}

package/esm2022/lib/components/form/transfer/transfer.model.mjs

@@ -0,0 +1,6 @@
+//Qs
+//Aria hidden?
+//state management with service?
+//interface?
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXIubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tYW5ndWxhci1raXQvc3JjL2xpYi9jb21wb25lbnRzL2Zvcm0vdHJhbnNmZXIvdHJhbnNmZXIubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSTtBQUNKLGNBQWM7QUFDZCxnQ0FBZ0M7QUFDaEMsWUFBWSIsInNvdXJjZXNDb250ZW50IjpbIi8vUXNcbi8vQXJpYSBoaWRkZW4/XG4vL3N0YXRlIG1hbmFnZW1lbnQgd2l0aCBzZXJ2aWNlP1xuLy9pbnRlcmZhY2U/XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHJhbnNmZXJJdGVtPFZhbHVlVHlwZT4ge1xuICB0ZXh0OiBzdHJpbmc7XG4gIHZhbHVlOiBWYWx1ZVR5cGU7XG59XG5cbmV4cG9ydCB0eXBlIFRyYW5zZmVySXRlbVNlbGVjdGlvbjxWYWx1ZVR5cGU+ID0gQXJyYXk8VHJhbnNmZXJJdGVtPFZhbHVlVHlwZT4+O1xuXG5leHBvcnQgdHlwZSBTb3VyY2VUeXBlID0gJ3NvdXJjZScgfCAndGFyZ2V0JztcbiJdfQ==

package/esm2022/lib/components/form/upload-drag-drop/upload-drag-drop.component.mjs

@@ -0,0 +1,142 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostListener, inject, Input, Output, ViewChild, } from '@angular/core';
+import { ItAbstractComponent } from '../../../abstracts/abstract.component';
+import { ItFileUtils } from '../../../utils/file-utils';
+import { ProgressDonut } from 'bootstrap-italia';
+import { ItIconComponent } from '../../utils/icon/icon.component';
+import { NgOptimizedImage } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { IT_ASSET_BASE_PATH } from '../../../interfaces/design-angular-kit-config';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class ItUploadDragDropComponent extends ItAbstractComponent {
+    constructor() {
+        super();
+        /**
+         * The accepted file type to upload <br>
+         * Possible values: <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types">MIME Types</a> separated by comma
+         * @example application/pdf,image/png
+         * @default *
+         */
+        this.accept = '*';
+        /**
+         * Fired when file start to upload
+         */
+        this.fileStartUpload = new EventEmitter();
+        this.isDragover = false;
+        this.isLoading = false;
+        this.isSuccess = false;
+        this.assetBasePath = inject(IT_ASSET_BASE_PATH);
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.donutElement) {
+            this.donut = ProgressDonut.getOrCreateInstance(this.donutElement.nativeElement);
+        }
+    }
+    // Dragover listener
+    onDragOver(evt) {
+        evt.preventDefault();
+        evt.stopPropagation();
+        this.isDragover = !this.isLoading;
+    }
+    // Dragleave listener
+    onDragLeave(evt) {
+        evt.preventDefault();
+        evt.stopPropagation();
+        this.isDragover = false;
+    }
+    // Drop leave listener
+    onDrop(evt) {
+        evt.preventDefault();
+        evt.stopPropagation();
+        this.isDragover = false;
+        const files = evt.dataTransfer?.files;
+        if (this.isLoading || !files?.length) {
+            return;
+        }
+        this.start(files[0]);
+    }
+    /**
+     * On load file from input
+     * @param event
+     */
+    onLoadFile(event) {
+        const files = event.target?.files;
+        if (!files?.length) {
+            return;
+        }
+        this.start(files[0]);
+    }
+    /**
+     * Start the upload file
+     * @param file
+     */
+    start(file) {
+        if (this.accept !== '*' && !this.accept.includes(file.type)) {
+            return;
+        }
+        this.reset();
+        this.isLoading = true;
+        const splitName = file.name.split('.');
+        this.filename = splitName[0];
+        this.extension = splitName[1]?.toUpperCase();
+        this.fileSize = ItFileUtils.getFileSizeString(file);
+        this.fileStartUpload.emit(file);
+    }
+    /**
+     * Percentage of upload
+     * @param value the percentage [0 - 100]
+     */
+    progress(value) {
+        if (!this.isLoading) {
+            return;
+        }
+        if (value >= 100) {
+            this.success();
+        }
+        else {
+            this.donut?.set((value < 0 ? 0 : value) / 100);
+        }
+    }
+    /**
+     * Upload success
+     */
+    success() {
+        this.isLoading = false;
+        this.isSuccess = true;
+        this._changeDetectorRef.detectChanges();
+    }
+    /**
+     * Reset file uploader
+     */
+    reset() {
+        this.isLoading = false;
+        this.isSuccess = false;
+        this.filename = this.extension = this.fileSize = undefined;
+        this.donut?.set(0);
+        this._changeDetectorRef.detectChanges();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItUploadDragDropComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.6", type: ItUploadDragDropComponent, isStandalone: true, selector: "it-upload-drag-drop", inputs: { accept: "accept" }, outputs: { fileStartUpload: "fileStartUpload" }, host: { listeners: { "dragover": "onDragOver($event)", "dragleave": "onDragLeave($event)", "drop": "onDrop($event)" } }, viewQueries: [{ propertyName: "donutElement", first: true, predicate: ["donutElement"], descendants: true }], exportAs: ["itUploadDragDrop"], usesInheritance: true, ngImport: i0, template: "<div class=\"upload-dragdrop\" [class.dragover]=\"isDragover\" [class.loading]=\"isLoading\" [class.success]=\"isSuccess\">\n  <div class=\"upload-dragdrop-image\">\n    <img\n      [ngSrc]=\"assetBasePath + '/dist/assets/upload-drag-drop-icon.svg'\"\n      alt=\"drag-drop-icon\"\n      aria-hidden=\"true\"\n      [width]=\"180\"\n      [height]=\"180\" />\n    <div class=\"upload-dragdrop-loading\">\n      <div class=\"progress-donut\" #donutElement></div>\n    </div>\n    <div class=\"upload-dragdrop-success\">\n      <it-icon name=\"check\"></it-icon>\n    </div>\n  </div>\n  <div class=\"upload-dragdrop-text\">\n    <p class=\"upload-dragdrop-weight\">\n      <it-icon name=\"file\" size=\"xs\"></it-icon>\n      {{ extension }} ({{ fileSize }})\n    </p>\n    <h5>{{ filename || ('it.form.upload-drag-file' | translate) }}</h5>\n    @if (isLoading) {\n      <p>{{ 'it.form.upload-loading' | translate }}</p>\n    }\n    @if (isSuccess) {\n      <p>{{ 'it.form.upload-complete' | translate }}</p>\n    }\n    @if (!isLoading && !isSuccess) {\n      <p>\n        {{ 'it.form.upload-or' | translate }}\n        <input type=\"file\" [id]=\"id\" class=\"upload-dragdrop-input\" [accept]=\"accept\" (change)=\"onLoadFile($event)\" />\n        <label [for]=\"id\">{{ 'it.form.upload-select-device' | translate }}</label>\n      </p>\n    }\n  </div>\n</div>\n", dependencies: [{ kind: "component", type: ItIconComponent, selector: "it-icon", inputs: ["name", "size", "color", "padded", "svgClass", "title", "labelWaria"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i1.TranslatePipe, name: "translate" }, { kind: "directive", type: NgOptimizedImage, selector: "img[ngSrc]", inputs: ["ngSrc", "ngSrcset", "sizes", "width", "height", "loading", "priority", "loaderParams", "disableOptimizedSrcset", "fill", "placeholder", "placeholderConfig", "src", "srcset"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItUploadDragDropComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'it-upload-drag-drop', exportAs: 'itUploadDragDrop', changeDetection: ChangeDetectionStrategy.OnPush, imports: [ItIconComponent, TranslateModule, NgOptimizedImage], template: "<div class=\"upload-dragdrop\" [class.dragover]=\"isDragover\" [class.loading]=\"isLoading\" [class.success]=\"isSuccess\">\n  <div class=\"upload-dragdrop-image\">\n    <img\n      [ngSrc]=\"assetBasePath + '/dist/assets/upload-drag-drop-icon.svg'\"\n      alt=\"drag-drop-icon\"\n      aria-hidden=\"true\"\n      [width]=\"180\"\n      [height]=\"180\" />\n    <div class=\"upload-dragdrop-loading\">\n      <div class=\"progress-donut\" #donutElement></div>\n    </div>\n    <div class=\"upload-dragdrop-success\">\n      <it-icon name=\"check\"></it-icon>\n    </div>\n  </div>\n  <div class=\"upload-dragdrop-text\">\n    <p class=\"upload-dragdrop-weight\">\n      <it-icon name=\"file\" size=\"xs\"></it-icon>\n      {{ extension }} ({{ fileSize }})\n    </p>\n    <h5>{{ filename || ('it.form.upload-drag-file' | translate) }}</h5>\n    @if (isLoading) {\n      <p>{{ 'it.form.upload-loading' | translate }}</p>\n    }\n    @if (isSuccess) {\n      <p>{{ 'it.form.upload-complete' | translate }}</p>\n    }\n    @if (!isLoading && !isSuccess) {\n      <p>\n        {{ 'it.form.upload-or' | translate }}\n        <input type=\"file\" [id]=\"id\" class=\"upload-dragdrop-input\" [accept]=\"accept\" (change)=\"onLoadFile($event)\" />\n        <label [for]=\"id\">{{ 'it.form.upload-select-device' | translate }}</label>\n      </p>\n    }\n  </div>\n</div>\n" }]
+        }], ctorParameters: () => [], propDecorators: { accept: [{
+                type: Input
+            }], fileStartUpload: [{
+                type: Output
+            }], donutElement: [{
+                type: ViewChild,
+                args: ['donutElement']
+            }], onDragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], onDragLeave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }], onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-drag-drop.component.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/form/upload-drag-drop/upload-drag-drop.component.ts","../../../../../../../projects/design-angular-kit/src/lib/components/form/upload-drag-drop/upload-drag-drop.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  inject,\n  Input,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport { ItAbstractComponent } from '../../../abstracts/abstract.component';\nimport { ItFileUtils } from '../../../utils/file-utils';\nimport { ProgressDonut } from 'bootstrap-italia';\nimport { ItIconComponent } from '../../utils/icon/icon.component';\nimport { NgOptimizedImage } from '@angular/common';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { IT_ASSET_BASE_PATH } from '../../../interfaces/design-angular-kit-config';\n\n@Component({\n  standalone: true,\n  selector: 'it-upload-drag-drop',\n  templateUrl: './upload-drag-drop.component.html',\n  exportAs: 'itUploadDragDrop',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [ItIconComponent, TranslateModule, NgOptimizedImage],\n})\nexport class ItUploadDragDropComponent extends ItAbstractComponent implements AfterViewInit {\n  /**\n   * The accepted file type to upload <br>\n   * Possible values: <a href=\"https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types\">MIME Types</a> separated by comma\n   * @example application/pdf,image/png\n   * @default *\n   */\n  @Input() accept: string = '*';\n\n  /**\n   * Fired when file start to upload\n   */\n  @Output() fileStartUpload = new EventEmitter<File>();\n\n  protected isDragover: boolean = false;\n  protected isLoading: boolean = false;\n  protected isSuccess: boolean = false;\n\n  protected donut?: ProgressDonut;\n\n  @ViewChild('donutElement') private donutElement?: ElementRef<HTMLDivElement>;\n\n  protected filename?: string;\n  protected extension?: string;\n  protected fileSize?: string;\n\n  /**\n   * The bootstrap-italia asset folder path\n   * @default ./bootstrap-italia\n   */\n  protected assetBasePath: string;\n\n  constructor() {\n    super();\n    this.assetBasePath = inject(IT_ASSET_BASE_PATH);\n  }\n\n  override ngAfterViewInit(): void {\n    super.ngAfterViewInit();\n    if (this.donutElement) {\n      this.donut = ProgressDonut.getOrCreateInstance(this.donutElement.nativeElement);\n    }\n  }\n\n  // Dragover listener\n  @HostListener('dragover', ['$event'])\n  public onDragOver(evt: DragEvent): void {\n    evt.preventDefault();\n    evt.stopPropagation();\n    this.isDragover = !this.isLoading;\n  }\n\n  // Dragleave listener\n  @HostListener('dragleave', ['$event'])\n  public onDragLeave(evt: DragEvent): void {\n    evt.preventDefault();\n    evt.stopPropagation();\n    this.isDragover = false;\n  }\n\n  // Drop leave listener\n  @HostListener('drop', ['$event'])\n  public onDrop(evt: DragEvent): void {\n    evt.preventDefault();\n    evt.stopPropagation();\n\n    this.isDragover = false;\n    const files = evt.dataTransfer?.files;\n    if (this.isLoading || !files?.length) {\n      return;\n    }\n    this.start(files[0]);\n  }\n\n  /**\n   * On load file from input\n   * @param event\n   */\n  onLoadFile(event: Event): void {\n    const files = (event.target as HTMLInputElement)?.files;\n    if (!files?.length) {\n      return;\n    }\n    this.start(files[0]);\n  }\n\n  /**\n   * Start the upload file\n   * @param file\n   */\n  public start(file: File): void {\n    if (this.accept !== '*' && !this.accept.includes(file.type)) {\n      return;\n    }\n\n    this.reset();\n    this.isLoading = true;\n\n    const splitName = file.name.split('.');\n    this.filename = splitName[0];\n    this.extension = splitName[1]?.toUpperCase();\n    this.fileSize = ItFileUtils.getFileSizeString(file);\n\n    this.fileStartUpload.emit(file);\n  }\n\n  /**\n   * Percentage of upload\n   * @param value the percentage [0 - 100]\n   */\n  public progress(value: number) {\n    if (!this.isLoading) {\n      return;\n    }\n\n    if (value >= 100) {\n      this.success();\n    } else {\n      this.donut?.set((value < 0 ? 0 : value) / 100);\n    }\n  }\n\n  /**\n   * Upload success\n   */\n  public success(): void {\n    this.isLoading = false;\n    this.isSuccess = true;\n    this._changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * Reset file uploader\n   */\n  public reset(): void {\n    this.isLoading = false;\n    this.isSuccess = false;\n    this.filename = this.extension = this.fileSize = undefined;\n    this.donut?.set(0);\n    this._changeDetectorRef.detectChanges();\n  }\n}\n","<div class=\"upload-dragdrop\" [class.dragover]=\"isDragover\" [class.loading]=\"isLoading\" [class.success]=\"isSuccess\">\n  <div class=\"upload-dragdrop-image\">\n    <img\n      [ngSrc]=\"assetBasePath + '/dist/assets/upload-drag-drop-icon.svg'\"\n      alt=\"drag-drop-icon\"\n      aria-hidden=\"true\"\n      [width]=\"180\"\n      [height]=\"180\" />\n    <div class=\"upload-dragdrop-loading\">\n      <div class=\"progress-donut\" #donutElement></div>\n    </div>\n    <div class=\"upload-dragdrop-success\">\n      <it-icon name=\"check\"></it-icon>\n    </div>\n  </div>\n  <div class=\"upload-dragdrop-text\">\n    <p class=\"upload-dragdrop-weight\">\n      <it-icon name=\"file\" size=\"xs\"></it-icon>\n      {{ extension }} ({{ fileSize }})\n    </p>\n    <h5>{{ filename || ('it.form.upload-drag-file' | translate) }}</h5>\n    @if (isLoading) {\n      <p>{{ 'it.form.upload-loading' | translate }}</p>\n    }\n    @if (isSuccess) {\n      <p>{{ 'it.form.upload-complete' | translate }}</p>\n    }\n    @if (!isLoading && !isSuccess) {\n      <p>\n        {{ 'it.form.upload-or' | translate }}\n        <input type=\"file\" [id]=\"id\" class=\"upload-dragdrop-input\" [accept]=\"accept\" (change)=\"onLoadFile($event)\" />\n        <label [for]=\"id\">{{ 'it.form.upload-select-device' | translate }}</label>\n      </p>\n    }\n  </div>\n</div>\n"]}

package/esm2022/lib/components/form/upload-file-list/upload-file-list.component.mjs

@@ -0,0 +1,107 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { ItAbstractComponent } from '../../../abstracts/abstract.component';
+import { ItFileUtils } from '../../../utils/file-utils';
+import { forkJoin, take, tap } from 'rxjs';
+import { ItIconComponent } from '../../utils/icon/icon.component';
+import { TranslateModule } from '@ngx-translate/core';
+import { ItTooltipDirective } from '../../core/tooltip/tooltip.directive';
+import { ItProgressBarComponent } from '../../core/progress-bar/progress-bar.component';
+import { inputToBoolean } from '../../../utils/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class ItUploadFileListComponent extends ItAbstractComponent {
+    constructor() {
+        super(...arguments);
+        /**
+         * The accepted file type to upload <br>
+         * Possible values: <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types">MIME Types</a> separated by comma
+         * @example application/pdf,image/png
+         * @default *
+         */
+        this.accept = '*';
+        /**
+         * If upload multiple files
+         * @default true
+         */
+        this.multiple = true;
+        /**
+         * Fired when upload new files
+         */
+        this.uploadFiles = new EventEmitter();
+        /**
+         * Fired on delete item button click
+         */
+        this.deleteItem = new EventEmitter();
+        /**
+         * Cache to preview image
+         */
+        this.previewImages = new Map();
+    }
+    ngOnInit() {
+        if (!!this.images && this.accept === '*') {
+            this.accept = 'image/*';
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['fileList'] && !!this.images) {
+            const images$ = this.fileList.map(item => ItFileUtils.fileToBase64(item.file).pipe(take(1), tap(base64 => this.previewImages.set(item.id, base64))));
+            forkJoin(images$).subscribe(() => {
+                this._changeDetectorRef.detectChanges();
+                super.ngOnChanges(changes);
+            });
+        }
+        else {
+            super.ngOnChanges(changes);
+        }
+    }
+    /**
+     * On load file from input
+     * @param event
+     */
+    onLoadFiles(event) {
+        const input = event.target;
+        const files = input?.files;
+        if (!files?.length) {
+            return;
+        }
+        const newFiles = Array.from(files).filter(file => !this.fileList.some(item => {
+            return item.file.name === file.name && item.file.size === file.size && item.file.type === file.type;
+        }));
+        const fileList = new DataTransfer();
+        newFiles.forEach(file => fileList.items.add(file));
+        this.uploadFiles.emit(fileList.files);
+        input.value = '';
+    }
+    /**
+     * Get the file size string
+     * @param file
+     */
+    getFileSize(file) {
+        return ItFileUtils.getFileSizeString(file);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItUploadFileListComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.6", type: ItUploadFileListComponent, isStandalone: true, selector: "it-upload-file-list", inputs: { fileList: "fileList", accept: "accept", multiple: ["multiple", "multiple", inputToBoolean], images: ["images", "images", inputToBoolean], hideLoadButton: ["hideLoadButton", "hideLoadButton", inputToBoolean] }, outputs: { uploadFiles: "uploadFiles", deleteItem: "deleteItem" }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "@if (!hideLoadButton) {\n  <input type=\"file\" [id]=\"id\" class=\"upload\" [accept]=\"accept\" [multiple]=\"multiple\" (change)=\"onLoadFiles($event)\" />\n  <label [for]=\"id\">\n    <it-icon name=\"upload\" size=\"sm\"></it-icon>\n    <span>{{ 'it.form.upload' | translate }}</span>\n  </label>\n}\n\n@if (fileList.length) {\n  <ul class=\"upload-file-list\" [class.upload-file-list-image]=\"images\">\n    @for (item of fileList; track item.id) {\n      <li\n        class=\"upload-file\"\n        [class.error]=\"item.error\"\n        [class.uploading]=\"!item.error && item.progress !== undefined && item.progress > 0 && item.progress < 100\"\n        [class.success]=\"!item.error && (!item.progress || item.progress >= 100)\">\n        @if (images) {\n          <div class=\"upload-image\">\n            <img [attr.src]=\"previewImages.get(item.id)\" [alt]=\"item.file.name\" />\n          </div>\n        } @else {\n          <it-icon name=\"file\" size=\"sm\" [color]=\"!item.error ? (item.progress ? 'secondary' : 'primary') : 'danger'\"></it-icon>\n        }\n        <p [itTooltip]=\"item.tooltip\">\n          <span class=\"visually-hidden\">{{ 'it.form.uploaded-file' | translate: { name: item.file.name } }}</span>\n          {{ item.file.name }} <span class=\"upload-file-weight\">{{ getFileSize(item.file) }}</span>\n        </p>\n        @if (item.removable && (!item.progress || item.progress < 100)) {\n          <button type=\"button\" (click)=\"deleteItem.emit(item)\">\n            <span class=\"visually-hidden\">{{ 'it.form.delete-file' | translate: { name: item.file.name } }}</span>\n            <it-icon name=\"close\"></it-icon>\n          </button>\n        }\n        @if ((!item.removable && !item.progress) || (item.progress !== undefined && item.progress >= 100)) {\n          <button type=\"button\" disabled>\n            <span class=\"visually-hidden\">{{ 'it.form.upload-complete' | translate }}</span>\n            <it-icon name=\"check\"></it-icon>\n          </button>\n        }\n        @if (!item.error && item.progress !== undefined && item.progress > 0 && item.progress < 100) {\n          <it-progress-bar [value]=\"item.progress!\"></it-progress-bar>\n        }\n      </li>\n    }\n  </ul>\n}\n", dependencies: [{ kind: "component", type: ItIconComponent, selector: "it-icon", inputs: ["name", "size", "color", "padded", "svgClass", "title", "labelWaria"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i1.TranslatePipe, name: "translate" }, { kind: "directive", type: ItTooltipDirective, selector: "[itTooltip]", inputs: ["itTooltip", "tooltipPlacement", "tooltipHtml"], outputs: ["showEvent", "shownEvent", "hideEvent", "hiddenEvent", "insertedEvent"], exportAs: ["itTooltip"] }, { kind: "component", type: ItProgressBarComponent, selector: "it-progress-bar", inputs: ["value", "showLabel", "indeterminate", "color"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: ItUploadFileListComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'it-upload-file-list', imports: [ItIconComponent, TranslateModule, ItTooltipDirective, ItProgressBarComponent], template: "@if (!hideLoadButton) {\n  <input type=\"file\" [id]=\"id\" class=\"upload\" [accept]=\"accept\" [multiple]=\"multiple\" (change)=\"onLoadFiles($event)\" />\n  <label [for]=\"id\">\n    <it-icon name=\"upload\" size=\"sm\"></it-icon>\n    <span>{{ 'it.form.upload' | translate }}</span>\n  </label>\n}\n\n@if (fileList.length) {\n  <ul class=\"upload-file-list\" [class.upload-file-list-image]=\"images\">\n    @for (item of fileList; track item.id) {\n      <li\n        class=\"upload-file\"\n        [class.error]=\"item.error\"\n        [class.uploading]=\"!item.error && item.progress !== undefined && item.progress > 0 && item.progress < 100\"\n        [class.success]=\"!item.error && (!item.progress || item.progress >= 100)\">\n        @if (images) {\n          <div class=\"upload-image\">\n            <img [attr.src]=\"previewImages.get(item.id)\" [alt]=\"item.file.name\" />\n          </div>\n        } @else {\n          <it-icon name=\"file\" size=\"sm\" [color]=\"!item.error ? (item.progress ? 'secondary' : 'primary') : 'danger'\"></it-icon>\n        }\n        <p [itTooltip]=\"item.tooltip\">\n          <span class=\"visually-hidden\">{{ 'it.form.uploaded-file' | translate: { name: item.file.name } }}</span>\n          {{ item.file.name }} <span class=\"upload-file-weight\">{{ getFileSize(item.file) }}</span>\n        </p>\n        @if (item.removable && (!item.progress || item.progress < 100)) {\n          <button type=\"button\" (click)=\"deleteItem.emit(item)\">\n            <span class=\"visually-hidden\">{{ 'it.form.delete-file' | translate: { name: item.file.name } }}</span>\n            <it-icon name=\"close\"></it-icon>\n          </button>\n        }\n        @if ((!item.removable && !item.progress) || (item.progress !== undefined && item.progress >= 100)) {\n          <button type=\"button\" disabled>\n            <span class=\"visually-hidden\">{{ 'it.form.upload-complete' | translate }}</span>\n            <it-icon name=\"check\"></it-icon>\n          </button>\n        }\n        @if (!item.error && item.progress !== undefined && item.progress > 0 && item.progress < 100) {\n          <it-progress-bar [value]=\"item.progress!\"></it-progress-bar>\n        }\n      </li>\n    }\n  </ul>\n}\n" }]
+        }], propDecorators: { fileList: [{
+                type: Input,
+                args: [{ required: true }]
+            }], accept: [{
+                type: Input
+            }], multiple: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], images: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], hideLoadButton: [{
+                type: Input,
+                args: [{ transform: inputToBoolean }]
+            }], uploadFiles: [{
+                type: Output
+            }], deleteItem: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-file-list.component.js","sourceRoot":"","sources":["../../../../../../../projects/design-angular-kit/src/lib/components/form/upload-file-list/upload-file-list.component.ts","../../../../../../../projects/design-angular-kit/src/lib/components/form/upload-file-list/upload-file-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';\nimport { ItAbstractComponent } from '../../../abstracts/abstract.component';\nimport { UploadFileListItem } from '../../../interfaces/form';\nimport { ItFileUtils } from '../../../utils/file-utils';\nimport { forkJoin, take, tap } from 'rxjs';\nimport { ItIconComponent } from '../../utils/icon/icon.component';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { ItTooltipDirective } from '../../core/tooltip/tooltip.directive';\nimport { ItProgressBarComponent } from '../../core/progress-bar/progress-bar.component';\nimport { inputToBoolean } from '../../../utils/coercion';\n\n@Component({\n  standalone: true,\n  selector: 'it-upload-file-list',\n  templateUrl: './upload-file-list.component.html',\n  imports: [ItIconComponent, TranslateModule, ItTooltipDirective, ItProgressBarComponent],\n})\nexport class ItUploadFileListComponent extends ItAbstractComponent implements OnInit, OnChanges {\n  /**\n   * The list of files to show in list\n   */\n  @Input({ required: true }) fileList!: Array<UploadFileListItem>;\n\n  /**\n   * The accepted file type to upload <br>\n   * Possible values: <a href=\"https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types\">MIME Types</a> separated by comma\n   * @example application/pdf,image/png\n   * @default *\n   */\n  @Input() accept: string = '*';\n\n  /**\n   * If upload multiple files\n   * @default true\n   */\n  @Input({ transform: inputToBoolean }) multiple: boolean = true;\n\n  /**\n   * If is file list image\n   * @default false\n   */\n  @Input({ transform: inputToBoolean }) images?: boolean;\n\n  /**\n   * Hide the load button\n   * @default false\n   */\n  @Input({ transform: inputToBoolean }) hideLoadButton?: boolean;\n\n  /**\n   * Fired when upload new files\n   */\n  @Output() uploadFiles: EventEmitter<FileList> = new EventEmitter<FileList>();\n\n  /**\n   * Fired on delete item button click\n   */\n  @Output() deleteItem: EventEmitter<UploadFileListItem> = new EventEmitter<UploadFileListItem>();\n\n  /**\n   * Cache to preview image\n   */\n  previewImages: Map<number, string> = new Map<number, string>();\n\n  ngOnInit(): void {\n    if (!!this.images && this.accept === '*') {\n      this.accept = 'image/*';\n    }\n  }\n\n  override ngOnChanges(changes: SimpleChanges): void {\n    if (changes['fileList'] && !!this.images) {\n      const images$ = this.fileList.map(item =>\n        ItFileUtils.fileToBase64(item.file).pipe(\n          take(1),\n          tap(base64 => this.previewImages.set(item.id, base64))\n        )\n      );\n      forkJoin(images$).subscribe(() => {\n        this._changeDetectorRef.detectChanges();\n        super.ngOnChanges(changes);\n      });\n    } else {\n      super.ngOnChanges(changes);\n    }\n  }\n\n  /**\n   * On load file from input\n   * @param event\n   */\n  onLoadFiles(event: Event): void {\n    const input = event.target as HTMLInputElement;\n    const files = input?.files;\n    if (!files?.length) {\n      return;\n    }\n\n    const newFiles = Array.from(files).filter(\n      file =>\n        !this.fileList.some(item => {\n          return item.file.name === file.name && item.file.size === file.size && item.file.type === file.type;\n        })\n    );\n\n    const fileList = new DataTransfer();\n    newFiles.forEach(file => fileList.items.add(file));\n\n    this.uploadFiles.emit(fileList.files);\n    input.value = '';\n  }\n\n  /**\n   * Get the file size string\n   * @param file\n   */\n  getFileSize(file: File): string {\n    return ItFileUtils.getFileSizeString(file);\n  }\n}\n","@if (!hideLoadButton) {\n  <input type=\"file\" [id]=\"id\" class=\"upload\" [accept]=\"accept\" [multiple]=\"multiple\" (change)=\"onLoadFiles($event)\" />\n  <label [for]=\"id\">\n    <it-icon name=\"upload\" size=\"sm\"></it-icon>\n    <span>{{ 'it.form.upload' | translate }}</span>\n  </label>\n}\n\n@if (fileList.length) {\n  <ul class=\"upload-file-list\" [class.upload-file-list-image]=\"images\">\n    @for (item of fileList; track item.id) {\n      <li\n        class=\"upload-file\"\n        [class.error]=\"item.error\"\n        [class.uploading]=\"!item.error && item.progress !== undefined && item.progress > 0 && item.progress < 100\"\n        [class.success]=\"!item.error && (!item.progress || item.progress >= 100)\">\n        @if (images) {\n          <div class=\"upload-image\">\n            <img [attr.src]=\"previewImages.get(item.id)\" [alt]=\"item.file.name\" />\n          </div>\n        } @else {\n          <it-icon name=\"file\" size=\"sm\" [color]=\"!item.error ? (item.progress ? 'secondary' : 'primary') : 'danger'\"></it-icon>\n        }\n        <p [itTooltip]=\"item.tooltip\">\n          <span class=\"visually-hidden\">{{ 'it.form.uploaded-file' | translate: { name: item.file.name } }}</span>\n          {{ item.file.name }} <span class=\"upload-file-weight\">{{ getFileSize(item.file) }}</span>\n        </p>\n        @if (item.removable && (!item.progress || item.progress < 100)) {\n          <button type=\"button\" (click)=\"deleteItem.emit(item)\">\n            <span class=\"visually-hidden\">{{ 'it.form.delete-file' | translate: { name: item.file.name } }}</span>\n            <it-icon name=\"close\"></it-icon>\n          </button>\n        }\n        @if ((!item.removable && !item.progress) || (item.progress !== undefined && item.progress >= 100)) {\n          <button type=\"button\" disabled>\n            <span class=\"visually-hidden\">{{ 'it.form.upload-complete' | translate }}</span>\n            <it-icon name=\"check\"></it-icon>\n          </button>\n        }\n        @if (!item.error && item.progress !== undefined && item.progress > 0 && item.progress < 100) {\n          <it-progress-bar [value]=\"item.progress!\"></it-progress-bar>\n        }\n      </li>\n    }\n  </ul>\n}\n"]}