@wemake4u/form-player-se 1.0.47 → 1.0.49

package/esm2022/lib/directives/file.directive.mjs

@@ -0,0 +1,212 @@
+import { Directive, Input } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { finalize, isObservable, take } from 'rxjs';
+import { downloadBlob, downloadFile } from '@wemake4u/interact';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/toast.service";
+export class FileHandlerDirective {
+    toastService;
+    destroyRef;
+    constructor(toastService, destroyRef) {
+        this.toastService = toastService;
+        this.destroyRef = destroyRef;
+    }
+    downloadHandler;
+    getExtension(file) {
+        const name = file?.name?.trim();
+        if (!name) {
+            return '';
+        }
+        const index = name.lastIndexOf('.');
+        if (index < 0 || index === name.length - 1) {
+            return '';
+        }
+        return name.substring(index + 1).toUpperCase();
+    }
+    getIcon(file) {
+        const extension = this.getExtension(file).toLowerCase();
+        return FILE_ICONS[extension] ?? 'fa-file';
+    }
+    getSize(file) {
+        const size = file?.size;
+        if (typeof size !== 'number' ||
+            !Number.isFinite(size) ||
+            size < 0) {
+            return '';
+        }
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        let value = size;
+        let unit = 0;
+        while (value >= 1024 &&
+            unit < units.length - 1) {
+            value /= 1024;
+            unit++;
+        }
+        const decimals = unit === 0
+            ? 0
+            : value < 10
+                ? 1
+                : 0;
+        return `${value.toFixed(decimals)} ${units[unit]}`;
+    }
+    canDownload(file) {
+        return this.isLocal(file)
+            || (this.isHandled(file) && !this.isDownloading(file));
+    }
+    isLocal(file) {
+        return file instanceof File;
+    }
+    downloadLocal(file) {
+        downloadBlob(file, file.name);
+    }
+    isHandled(file) {
+        return !this.isLocal(file)
+            && typeof file === 'object'
+            && file !== null
+            && 'name' in file
+            && 'type' in file
+            && typeof file.name === 'string'
+            && this.downloadHandler != null;
+    }
+    downloadHandled(file) {
+        if (!this.downloadHandler || !this.isHandled(file))
+            return;
+        const downloadResult = this.downloadHandler(file);
+        if (typeof downloadResult === 'string') {
+            this.downloadUrl(downloadResult, file.name);
+        }
+        if (isObservable(downloadResult)) {
+            this.downloadingHandled.add(file);
+            downloadResult
+                .pipe(take(1), finalize(() => this.downloadingHandled.delete(file)), takeUntilDestroyed(this.destroyRef))
+                .subscribe({
+                next: (result) => {
+                    if (this.isBase64(result)) {
+                        downloadFile(result, file.name, file.type);
+                    }
+                    else if (this.isUri(result)) {
+                        this.downloadUrl(result, file.name);
+                    }
+                },
+                error: error => {
+                    this.logError(error);
+                }
+            });
+        }
+    }
+    isDownloading(file) {
+        return this.downloadingHandled.has(file);
+    }
+    downloadingHandled = new WeakSet();
+    downloadUrl(url, fileName) {
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = fileName;
+        link.target = '_blank';
+        link.click();
+    }
+    isBase64(value) {
+        if (!value) {
+            return false;
+        }
+        // Data URI
+        if (value.startsWith('data:')) {
+            return value.includes(';base64,');
+        }
+        // Lunghezza multipla di 4
+        if (value.length % 4 !== 0) {
+            return false;
+        }
+        // Caratteri validi Base64
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
+            return false;
+        }
+        try {
+            atob(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    isUri(value) {
+        try {
+            new URL(value, window.location.origin);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    logError(error) {
+        if (!error)
+            return;
+        console.error(error);
+        if (error.message)
+            this.toastService.notifyError(error.message);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FileHandlerDirective, deps: [{ token: i1.ToastService }, { token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: FileHandlerDirective, isStandalone: true, selector: "[fileHandler]", inputs: { downloadHandler: "downloadHandler" }, exportAs: ["fileHandler"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FileHandlerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fileHandler]',
+                    exportAs: 'fileHandler',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.ToastService }, { type: i0.DestroyRef }], propDecorators: { downloadHandler: [{
+                type: Input
+            }] } });
+const FILE_ICONS = {
+    zip: 'fa-file-zipper',
+    rar: 'fa-file-zipper',
+    '7z': 'fa-file-zipper',
+    tar: 'fa-file-zipper',
+    gz: 'fa-file-zipper',
+    doc: 'fa-file-word',
+    docx: 'fa-file-word',
+    ppt: 'fa-file-powerpoint',
+    pptx: 'fa-file-powerpoint',
+    txt: 'fa-file-lines',
+    log: 'fa-file-lines',
+    md: 'fa-file-lines',
+    pdf: 'fa-file-pdf',
+    jpg: 'fa-file-image',
+    jpeg: 'fa-file-image',
+    png: 'fa-file-image',
+    gif: 'fa-file-image',
+    bmp: 'fa-file-image',
+    svg: 'fa-file-image',
+    webp: 'fa-file-image',
+    xls: 'fa-file-excel',
+    xlsx: 'fa-file-excel',
+    csv: 'fa-file-csv',
+    mp3: 'fa-file-audio',
+    wav: 'fa-file-audio',
+    ogg: 'fa-file-audio',
+    flac: 'fa-file-audio',
+    aac: 'fa-file-audio',
+    m4a: 'fa-file-audio',
+    wma: 'fa-file-audio',
+    mp4: 'fa-file-video',
+    avi: 'fa-file-video',
+    mov: 'fa-file-video',
+    wmv: 'fa-file-video',
+    mkv: 'fa-file-video',
+    webm: 'fa-file-video',
+    mpeg: 'fa-file-video',
+    mpg: 'fa-file-video',
+    m4v: 'fa-file-video',
+    html: 'fa-file-code',
+    css: 'fa-file-code',
+    js: 'fa-file-code',
+    ts: 'fa-file-code',
+    json: 'fa-file-code',
+    xml: 'fa-file-code',
+    cs: 'fa-file-code',
+    java: 'fa-file-code',
+    py: 'fa-file-code',
+    sql: 'fa-file-code'
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.directive.js","sourceRoot":"","sources":["../../../../../projects/ngx-sirio/src/lib/directives/file.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Directive, Input } from '@angular/core';\r\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\r\nimport { finalize, isObservable, Observable, take } from 'rxjs';\r\nimport { ToastService } from '../services/toast.service';\r\nimport { downloadBlob, downloadFile } from '@wemake4u/interact'\r\n\r\n@Directive({\r\n  selector: '[fileHandler]',\r\n  exportAs: 'fileHandler',\r\n  standalone: true\r\n})\r\nexport class FileHandlerDirective {\r\n\r\n  constructor(\r\n    protected toastService: ToastService,\r\n    protected destroyRef: DestroyRef\r\n  ) { }\r\n\r\n  @Input()\r\n  downloadHandler?: (file: any) => Observable<any> | string;\r\n\r\n  getExtension(file?: FileInfo | null): string {\r\n    const name = file?.name?.trim();\r\n\r\n    if (!name) {\r\n      return '';\r\n    }\r\n\r\n    const index = name.lastIndexOf('.');\r\n\r\n    if (index < 0 || index === name.length - 1) {\r\n      return '';\r\n    }\r\n\r\n    return name.substring(index + 1).toUpperCase();\r\n  }\r\n\r\n  getIcon(file: File): string {\r\n    const extension = this.getExtension(file).toLowerCase();\r\n    return FILE_ICONS[extension] ?? 'fa-file';\r\n  }\r\n\r\n  getSize(file?: FileInfo | null): string {\r\n    const size = file?.size;\r\n\r\n    if (\r\n      typeof size !== 'number' ||\r\n      !Number.isFinite(size) ||\r\n      size < 0\r\n    ) {\r\n      return '';\r\n    }\r\n\r\n    const units = ['B', 'KB', 'MB', 'GB', 'TB'];\r\n\r\n    let value = size;\r\n    let unit = 0;\r\n\r\n    while (\r\n      value >= 1024 &&\r\n      unit < units.length - 1\r\n    ) {\r\n      value /= 1024;\r\n      unit++;\r\n    }\r\n\r\n    const decimals =\r\n      unit === 0\r\n        ? 0\r\n        : value < 10\r\n          ? 1\r\n          : 0;\r\n\r\n    return `${value.toFixed(decimals)} ${units[unit]}`;\r\n  }\r\n\r\n  canDownload(file: any): boolean {\r\n    return this.isLocal(file)\r\n      || (this.isHandled(file) && !this.isDownloading(file));\r\n  }\r\n\r\n  isLocal(file: any): file is File {\r\n    return file instanceof File;\r\n  }\r\n\r\n  downloadLocal(file: File): void {\r\n    downloadBlob(file, file.name);    \r\n  }\r\n\r\n  isHandled(file: any): file is { name: string, type: string } {\r\n    return !this.isLocal(file)\r\n      && typeof file === 'object'\r\n      && file !== null\r\n      && 'name' in file\r\n      && 'type' in file      \r\n      && typeof file.name === 'string'\r\n      && this.downloadHandler != null;\r\n  }\r\n\r\n  downloadHandled(file: any): void {\r\n\r\n    if (!this.downloadHandler || !this.isHandled(file))\r\n      return;\r\n\r\n    const downloadResult = this.downloadHandler(file);\r\n\r\n    if (typeof downloadResult === 'string') {\r\n      this.downloadUrl(downloadResult, file.name);      \r\n    }\r\n\r\n    if (isObservable(downloadResult)) {\r\n\r\n      this.downloadingHandled.add(file);\r\n\r\n      downloadResult\r\n        .pipe(\r\n          take(1),\r\n          finalize(() => this.downloadingHandled.delete(file)),\r\n          takeUntilDestroyed(this.destroyRef)\r\n        )\r\n        .subscribe({\r\n          next: (result: any) => {\r\n            if (this.isBase64(result)) {\r\n              downloadFile(result, file.name, file.type);\r\n            }\r\n            else if (this.isUri(result)) {\r\n              this.downloadUrl(result, file.name);\r\n            }\r\n          },\r\n          error: error => {\r\n            this.logError(error);\r\n          }\r\n        });\r\n    }\r\n  }\r\n\r\n  isDownloading(file: any): boolean {\r\n    return this.downloadingHandled.has(file);\r\n  }\r\n\r\n  private readonly downloadingHandled = new WeakSet<object>();\r\n\r\n  private downloadUrl(url: string, fileName: string) {\r\n    const link = document.createElement('a');\r\n    link.href = url;\r\n    link.download = fileName;\r\n    link.target = '_blank';\r\n    link.click();\r\n  }\r\n\r\n  private isBase64(value: string): boolean {\r\n    if (!value) {\r\n      return false;\r\n    }\r\n\r\n    // Data URI\r\n    if (value.startsWith('data:')) {\r\n      return value.includes(';base64,');\r\n    }\r\n\r\n    // Lunghezza multipla di 4\r\n    if (value.length % 4 !== 0) {\r\n      return false;\r\n    }\r\n\r\n    // Caratteri validi Base64\r\n    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {\r\n      return false;\r\n    }\r\n\r\n    try {\r\n      atob(value);\r\n      return true;\r\n    } catch {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  private isUri(value: string): boolean {\r\n    try {\r\n      new URL(value, window.location.origin);\r\n      return true;\r\n    } catch {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  protected logError(error: Error) {\r\n    if (!error) return;\r\n    console.error(error);\r\n    if (error.message)\r\n      this.toastService.notifyError(error.message);\r\n  }\r\n\r\n}\r\n\r\ntype FileInfo = Pick<File, 'name' | 'size'>;\r\n\r\nconst FILE_ICONS: Record<string, string> = {\r\n  zip: 'fa-file-zipper',\r\n  rar: 'fa-file-zipper',\r\n  '7z': 'fa-file-zipper',\r\n  tar: 'fa-file-zipper',\r\n  gz: 'fa-file-zipper',\r\n\r\n  doc: 'fa-file-word',\r\n  docx: 'fa-file-word',\r\n\r\n  ppt: 'fa-file-powerpoint',\r\n  pptx: 'fa-file-powerpoint',\r\n\r\n  txt: 'fa-file-lines',\r\n  log: 'fa-file-lines',\r\n  md: 'fa-file-lines',\r\n\r\n  pdf: 'fa-file-pdf',\r\n\r\n  jpg: 'fa-file-image',\r\n  jpeg: 'fa-file-image',\r\n  png: 'fa-file-image',\r\n  gif: 'fa-file-image',\r\n  bmp: 'fa-file-image',\r\n  svg: 'fa-file-image',\r\n  webp: 'fa-file-image',\r\n\r\n  xls: 'fa-file-excel',\r\n  xlsx: 'fa-file-excel',\r\n\r\n  csv: 'fa-file-csv',\r\n\r\n  mp3: 'fa-file-audio',\r\n  wav: 'fa-file-audio',\r\n  ogg: 'fa-file-audio',\r\n  flac: 'fa-file-audio',\r\n  aac: 'fa-file-audio',\r\n  m4a: 'fa-file-audio',\r\n  wma: 'fa-file-audio',\r\n\r\n  mp4: 'fa-file-video',\r\n  avi: 'fa-file-video',\r\n  mov: 'fa-file-video',\r\n  wmv: 'fa-file-video',\r\n  mkv: 'fa-file-video',\r\n  webm: 'fa-file-video',\r\n  mpeg: 'fa-file-video',\r\n  mpg: 'fa-file-video',\r\n  m4v: 'fa-file-video',\r\n\r\n  html: 'fa-file-code',\r\n  css: 'fa-file-code',\r\n  js: 'fa-file-code',\r\n  ts: 'fa-file-code',\r\n  json: 'fa-file-code',\r\n  xml: 'fa-file-code',\r\n  cs: 'fa-file-code',\r\n  java: 'fa-file-code',\r\n  py: 'fa-file-code',\r\n  sql: 'fa-file-code'\r\n};\r\n"]}

package/esm2022/lib/directives/filemanager.directive.mjs

@@ -0,0 +1,233 @@
+import { Directive, Input, Self } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Subscription, take, tap } from 'rxjs';
+import { FileHandlerDirective } from './file.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "ngx-sirio-lib";
+import * as i3 from "../services/toast.service";
+export class FileManagerDirective extends FileHandlerDirective {
+    ngControl;
+    fileUpload;
+    renderer;
+    instantUpload = false;
+    readonly = false;
+    multiple = false;
+    uploadHandler;
+    deleteHandler;
+    constructor(ngControl, fileUpload, renderer, toastService, destroyRef) {
+        super(toastService, destroyRef);
+        this.ngControl = ngControl;
+        this.fileUpload = fileUpload;
+        this.renderer = renderer;
+    }
+    ngOnDestroy() {
+        this.cleanupInstant();
+    }
+    ngOnChanges(changes) {
+        if (changes["instantUpload"] || changes["multiple"]
+            || changes["uploadHandler"] || changes["deleteHandler"]) {
+            this.cleanupInstant();
+            if (this.instantUpload && this.uploadHandler && this.deleteHandler) {
+                this.setupInstant();
+            }
+            this.setupButton();
+        }
+    }
+    canRemove(file) {
+        if (this.readonly || !file)
+            return false;
+        if (this.instantUpload)
+            return !this.isUploading(file) && !this.isDeleting(file);
+        return true;
+    }
+    removeFile(file) {
+        if (!this.canRemove(file))
+            return;
+        this.onRemovingFile(file);
+    }
+    canDownload(file) {
+        if (!this.instantUpload)
+            return super.canDownload(file);
+        return !this.isUploading(file)
+            && !this.isDeleting(file)
+            && super.canDownload(file);
+    }
+    isUploading(file) {
+        return this.getStatus(file) === UploadStatus.Uploading;
+    }
+    isDeleting(file) {
+        return this.getStatus(file) === UploadStatus.Deleting;
+    }
+    instantSubscription = new Subscription();
+    lastSingleUploaded = null;
+    setupInstant() {
+        this.instantSubscription.add(this.fileUpload.fileUploadedEvent.subscribe((e) => {
+            const target = e.event.target;
+            if (this.multiple) {
+                for (const file of Array.from(target.files ?? [])) {
+                    this.onAddFile(file);
+                }
+            }
+            else {
+                if (this.lastSingleUploaded)
+                    this.onRemoveFile(this.lastSingleUploaded);
+                this.lastSingleUploaded = target.files?.[0] ?? null;
+                this.onAddFile(this.lastSingleUploaded);
+            }
+        }));
+        this.instantSubscription.add(this.fileUpload.fileDeletedEvent.subscribe((e) => {
+            this.onRemoveFile(e.data.fileDeleted);
+        }));
+        this.lastSingleUploaded = null;
+    }
+    cleanupInstant() {
+        this.instantSubscription.unsubscribe();
+        this.instantSubscription = new Subscription();
+        this.lastSingleUploaded = null;
+    }
+    setupButton() {
+        this.instantSubscription.add(this.ngControl.control?.valueChanges.subscribe(value => {
+            this.refreshButton(value);
+        }));
+        setTimeout(() => this.refreshButton(this.ngControl.control?.value));
+    }
+    onAddFile(file) {
+        if (!file || !this.uploadHandler)
+            return;
+        this.setStatus(file, UploadStatus.Uploading);
+        this.uploadHandler(file)
+            .pipe(take(1), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: result => {
+                this.setStatus(file, UploadStatus.Uploaded);
+                this.markUploaded(file, result);
+            },
+            error: error => {
+                this.setStatus(file, UploadStatus.Failed);
+                this.removeFromUploader(file);
+                this.logError(error);
+            }
+        });
+    }
+    onRemoveFile(file) {
+        if (!file)
+            return;
+        const currentStatus = this.getStatus(file);
+        const shouldDelete = this.deleteHandler
+            && (currentStatus === UploadStatus.Uploaded
+                || currentStatus == null);
+        if (!shouldDelete)
+            return;
+        this.deleteHandler?.(file)
+            .pipe(take(1), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: result => {
+                this.setStatus(file, undefined);
+            },
+            error: error => {
+                this.logError(error);
+            }
+        });
+    }
+    onRemovingFile(file) {
+        if (!this.deleteHandler) {
+            this.removeFromUploader(file);
+            return;
+        }
+        const currentStatus = this.getStatus(file);
+        this.setStatus(file, UploadStatus.Deleting);
+        this.deleteHandler?.(file)
+            .pipe(take(1), tap(result => {
+            if (!result) {
+                throw new Error('Delete failed');
+            }
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: result => {
+                this.setStatus(file, UploadStatus.Deleted);
+                this.removeFromUploader(file);
+            },
+            error: error => {
+                this.setStatus(file, currentStatus);
+                this.logError(error);
+            }
+        });
+    }
+    removeFromUploader(file) {
+        this.fileUpload.onFileDeleted(file);
+    }
+    refreshButton(value) {
+        const hideButton = (value?.length ?? 0) > 0 && !this.multiple;
+        const button = this.fileUpload.sirioInput?.sirioButton?.nativeElement;
+        if (!button)
+            return;
+        this.renderer[hideButton ? 'addClass' : 'removeClass'](button, 'd-none');
+    }
+    markUploaded(file, result) {
+        for (const [key, value] of Object.entries(result)) {
+            if (key in file) {
+                continue;
+            }
+            Object.defineProperty(file, key, {
+                value,
+                writable: false,
+                enumerable: true,
+                configurable: false
+            });
+        }
+        Object.defineProperty(file, "uploaded", {
+            value: true,
+            writable: false,
+            enumerable: false,
+            configurable: false
+        });
+    }
+    getStatus(file) {
+        return file.status;
+    }
+    setStatus(file, status) {
+        const key = 'status';
+        if (Object.prototype.hasOwnProperty.call(file, key)) {
+            file[key] = status;
+            return;
+        }
+        Object.defineProperty(file, key, {
+            value: status,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FileManagerDirective, deps: [{ token: i1.NgControl, self: true }, { token: i2.SirioFileUploadComponent }, { token: i0.Renderer2 }, { token: i3.ToastService }, { token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: FileManagerDirective, isStandalone: true, selector: "[fileManager]", inputs: { instantUpload: "instantUpload", readonly: "readonly", multiple: "multiple", uploadHandler: "uploadHandler", deleteHandler: "deleteHandler" }, exportAs: ["fileManager"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FileManagerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fileManager]',
+                    exportAs: 'fileManager',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }] }, { type: i2.SirioFileUploadComponent }, { type: i0.Renderer2 }, { type: i3.ToastService }, { type: i0.DestroyRef }], propDecorators: { instantUpload: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], uploadHandler: [{
+                type: Input
+            }], deleteHandler: [{
+                type: Input
+            }] } });
+export var UploadStatus;
+(function (UploadStatus) {
+    UploadStatus[UploadStatus["Uploading"] = 0] = "Uploading";
+    UploadStatus[UploadStatus["Uploaded"] = 1] = "Uploaded";
+    UploadStatus[UploadStatus["Deleting"] = 2] = "Deleting";
+    UploadStatus[UploadStatus["Deleted"] = 3] = "Deleted";
+    UploadStatus[UploadStatus["Failed"] = 4] = "Failed";
+})(UploadStatus || (UploadStatus = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filemanager.directive.js","sourceRoot":"","sources":["../../../../../projects/ngx-sirio/src/lib/directives/filemanager.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Directive, Input, OnChanges, OnDestroy, Renderer2, Self, SimpleChanges } from '@angular/core';\r\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\r\nimport { NgControl } from '@angular/forms';\r\nimport { SirioFileUploadComponent } from 'ngx-sirio-lib';\r\nimport { Observable, Subscription, take, tap } from 'rxjs';\r\nimport { ToastService } from '../services/toast.service';\r\nimport { FileHandlerDirective } from './file.directive';\r\n\r\n@Directive({\r\n  selector: '[fileManager]',\r\n  exportAs: 'fileManager',\r\n  standalone: true\r\n})\r\nexport class FileManagerDirective extends FileHandlerDirective implements OnChanges, OnDestroy {\r\n\r\n  @Input()\r\n  instantUpload: boolean | null = false;\r\n\r\n  @Input()\r\n  readonly: boolean | null = false;\r\n\r\n  @Input()\r\n  multiple: boolean | null = false;\r\n\r\n  @Input()\r\n  uploadHandler?: (file: File) => Observable<any>;\r\n\r\n  @Input()\r\n  deleteHandler?: (file: File) => Observable<boolean>;\r\n\r\n  constructor(\r\n    @Self() private ngControl: NgControl,\r\n    private fileUpload: SirioFileUploadComponent,\r\n    private renderer: Renderer2,\r\n    toastService: ToastService,\r\n    destroyRef: DestroyRef\r\n  ) {\r\n    super(toastService, destroyRef);\r\n  }\r\n  \r\n  ngOnDestroy(): void {\r\n    this.cleanupInstant();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes[\"instantUpload\"] || changes[\"multiple\"]\r\n      || changes[\"uploadHandler\"] || changes[\"deleteHandler\"] ) {\r\n      this.cleanupInstant();\r\n\r\n      if (this.instantUpload && this.uploadHandler && this.deleteHandler) {\r\n        this.setupInstant();\r\n      }\r\n\r\n      this.setupButton();        \r\n    }\r\n  }\r\n\r\n  canRemove(file: File): boolean\r\n  {\r\n    if (this.readonly || !file)\r\n      return false;\r\n\r\n    if (this.instantUpload)\r\n      return !this.isUploading(file) && !this.isDeleting(file);\r\n\r\n    return true;\r\n  }\r\n\r\n  removeFile(file: File) {\r\n\r\n    if (!this.canRemove(file))\r\n      return;\r\n\r\n    this.onRemovingFile(file);\r\n  }\r\n\r\n  override canDownload(file: File): boolean {\r\n    if (!this.instantUpload)\r\n      return super.canDownload(file);\r\n\r\n    return !this.isUploading(file)\r\n      && !this.isDeleting(file)\r\n      && super.canDownload(file);\r\n  }\r\n\r\n  isUploading(file: File) {\r\n    return this.getStatus(file) === UploadStatus.Uploading;\r\n  }\r\n\r\n  isDeleting(file: File) {\r\n    return this.getStatus(file) === UploadStatus.Deleting;\r\n  }\r\n\r\n  private instantSubscription = new Subscription();\r\n\r\n  private lastSingleUploaded: File | null = null;\r\n\r\n  private setupInstant() {\r\n\r\n    this.instantSubscription.add(\r\n      this.fileUpload.fileUploadedEvent.subscribe((e) => {\r\n\r\n        const target = e.event.target as HTMLInputElement;\r\n\r\n        if (this.multiple) {\r\n          for (const file of Array.from(target.files ?? [])) {\r\n            this.onAddFile(file);\r\n          }\r\n        }\r\n        else {\r\n\r\n          if (this.lastSingleUploaded)\r\n            this.onRemoveFile(this.lastSingleUploaded);\r\n\r\n          this.lastSingleUploaded = target.files?.[0] ?? null;\r\n          \r\n          this.onAddFile(this.lastSingleUploaded);\r\n        }\r\n\r\n      })\r\n    );\r\n\r\n    this.instantSubscription.add(\r\n      this.fileUpload.fileDeletedEvent.subscribe((e) => {        \r\n        this.onRemoveFile(e.data.fileDeleted);\r\n      })\r\n    );\r\n\r\n    this.lastSingleUploaded = null;\r\n  }\r\n\r\n  private cleanupInstant() {\r\n    this.instantSubscription.unsubscribe();\r\n    this.instantSubscription = new Subscription();\r\n\r\n    this.lastSingleUploaded = null;\r\n  }\r\n\r\n  private setupButton() {\r\n    this.instantSubscription.add(\r\n      this.ngControl.control?.valueChanges.subscribe(value => {\r\n        this.refreshButton(value);\r\n      })\r\n    );\r\n    setTimeout(() => this.refreshButton(this.ngControl.control?.value));\r\n  }\r\n\r\n  private onAddFile(file: File | null): void {\r\n    \r\n    if (!file || !this.uploadHandler)\r\n      return;\r\n\r\n    this.setStatus(file, UploadStatus.Uploading);\r\n\r\n    this.uploadHandler(file)\r\n      .pipe(\r\n        take(1),\r\n        takeUntilDestroyed(this.destroyRef)\r\n      )\r\n      .subscribe({\r\n        next: result => {\r\n          this.setStatus(file, UploadStatus.Uploaded);\r\n          this.markUploaded(file, result);\r\n        },\r\n        error: error => {\r\n          this.setStatus(file, UploadStatus.Failed);\r\n          this.removeFromUploader(file);\r\n          this.logError(error);\r\n        }\r\n      })\r\n  }\r\n\r\n  private onRemoveFile(file: File | null): void {\r\n\r\n    if (!file)\r\n      return;\r\n\r\n    const currentStatus = this.getStatus(file);\r\n\r\n    const shouldDelete = this.deleteHandler\r\n      && (currentStatus === UploadStatus.Uploaded\r\n      || currentStatus == null);\r\n\r\n    if (!shouldDelete)\r\n      return;\r\n\r\n    this.deleteHandler?.(file)\r\n      .pipe(\r\n        take(1),\r\n        takeUntilDestroyed(this.destroyRef)\r\n      )\r\n      .subscribe({\r\n        next: result => {\r\n          this.setStatus(file, undefined);\r\n        },\r\n        error: error => {\r\n          this.logError(error);\r\n        }\r\n      });\r\n  }\r\n\r\n  private onRemovingFile(file: File) {\r\n\r\n    if (!this.deleteHandler) {\r\n      this.removeFromUploader(file);\r\n      return;\r\n    }\r\n\r\n    const currentStatus = this.getStatus(file);\r\n\r\n    this.setStatus(file, UploadStatus.Deleting);\r\n\r\n    this.deleteHandler?.(file)\r\n      .pipe(\r\n        take(1),\r\n        tap(result => {\r\n          if (!result) {\r\n            throw new Error('Delete failed');\r\n          }\r\n        }),\r\n        takeUntilDestroyed(this.destroyRef)\r\n      )\r\n      .subscribe({\r\n        next: result => {\r\n          this.setStatus(file, UploadStatus.Deleted);\r\n          this.removeFromUploader(file);\r\n        },\r\n        error: error => {\r\n          this.setStatus(file, currentStatus);\r\n          this.logError(error);\r\n        }\r\n      });  \r\n  }\r\n\r\n  private removeFromUploader(file: File) {\r\n    this.fileUpload.onFileDeleted(file);\r\n  }\r\n\r\n  private refreshButton(value: any) {\r\n    const hideButton = (value?.length ?? 0) > 0 && !this.multiple;\r\n\r\n    const button = this.fileUpload.sirioInput?.sirioButton?.nativeElement;\r\n\r\n    if (!button)\r\n      return;\r\n\r\n    this.renderer[hideButton ? 'addClass' : 'removeClass'](\r\n      button,\r\n      'd-none'\r\n    );\r\n  }\r\n\r\n  private markUploaded(file: File, result: Record<string, any>) {\r\n\r\n    for (const [key, value] of Object.entries(result)) {\r\n\r\n      if (key in file) {\r\n        continue;\r\n      }\r\n\r\n      Object.defineProperty(file, key, {\r\n        value,\r\n        writable: false,\r\n        enumerable: true,\r\n        configurable: false\r\n      });\r\n    }\r\n\r\n    Object.defineProperty(file, \"uploaded\", {\r\n      value: true,\r\n      writable: false,\r\n      enumerable: false,\r\n      configurable: false\r\n    });\r\n  }\r\n\r\n  private getStatus(file: File): UploadStatus | undefined {\r\n    return (file as any).status;\r\n  }\r\n\r\n  private setStatus(file: File, status: UploadStatus | undefined): void {\r\n    const key = 'status';\r\n\r\n    if (Object.prototype.hasOwnProperty.call(file, key)) {\r\n      (file as any)[key] = status;\r\n      return;\r\n    }\r\n\r\n    Object.defineProperty(file, key, {\r\n      value: status,\r\n      writable: true,\r\n      enumerable: false,\r\n      configurable: true\r\n    });\r\n  }\r\n}\r\n\r\nexport enum UploadStatus {\r\n  Uploading,\r\n  Uploaded,\r\n  Deleting,\r\n  Deleted,\r\n  Failed\r\n}\r\n"]}

package/esm2022/lib/directives/filepicker.directive.mjs

@@ -0,0 +1,40 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FileListReadonlyDirective {
+    host;
+    renderer;
+    readonly = false;
+    constructor(host, renderer) {
+        this.host = host;
+        this.renderer = renderer;
+    }
+    ngAfterViewChecked() {
+        const buttons = this.host.nativeElement.querySelectorAll('.sirio-upload-file-list button');
+        buttons.forEach((button, index) => {
+            if (this.readonly) {
+                this.renderer.setAttribute(button, 'disabled', '');
+            }
+            else {
+                this.renderer.removeAttribute(button, 'disabled');
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FileListReadonlyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: FileListReadonlyDirective, isStandalone: true, selector: "ngx-sirio-file-upload", inputs: { readonly: "readonly" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FileListReadonlyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngx-sirio-file-upload',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { readonly: [{
+                type: Input
+            }] } });
+export var UploadStatus;
+(function (UploadStatus) {
+    UploadStatus[UploadStatus["Uploading"] = 0] = "Uploading";
+    UploadStatus[UploadStatus["Uploaded"] = 1] = "Uploaded";
+    UploadStatus[UploadStatus["Failed"] = 2] = "Failed";
+})(UploadStatus || (UploadStatus = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/jsonfile.directive.mjs

@@ -0,0 +1,59 @@
+import { Directive, Self } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../services/subscribe.service";
+export class JsonFileDirective {
+    ngControl;
+    subscribe;
+    destroyRef;
+    constructor(ngControl, subscribe, destroyRef) {
+        this.ngControl = ngControl;
+        this.subscribe = subscribe;
+        this.destroyRef = destroyRef;
+    }
+    ngOnInit() {
+        const control = this.ngControl.control;
+        if (!control)
+            return;
+        this.subscribe.subscribeChanges(control.valueChanges, control, undefined, this.destroyRef, (_, n) => this.defineJson(n));
+    }
+    defineJson(value) {
+        if (!Array.isArray(value)) {
+            return;
+        }
+        for (const item of value) {
+            if (!(item instanceof File)) {
+                continue;
+            }
+            if (typeof item.toJSON === 'function') {
+                continue;
+            }
+            Object.defineProperty(item, 'toJSON', {
+                value() {
+                    return {
+                        ...this,
+                        name: this.name,
+                        size: this.size,
+                        type: this.type,
+                        lastModified: this.lastModified
+                    };
+                },
+                writable: true,
+                configurable: true,
+                enumerable: false
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: JsonFileDirective, deps: [{ token: i1.NgControl, self: true }, { token: i2.SubscribeService }, { token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: JsonFileDirective, isStandalone: true, selector: "ngx-sirio-file-upload", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: JsonFileDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngx-sirio-file-upload',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }] }, { type: i2.SubscribeService }, { type: i0.DestroyRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbmZpbGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXNpcmlvL3NyYy9saWIvZGlyZWN0aXZlcy9qc29uZmlsZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFjLFNBQVMsRUFBVSxJQUFJLEVBQUUsTUFBTSxlQUFlLENBQUM7Ozs7QUFRcEUsTUFBTSxPQUFPLGlCQUFpQjtJQUdWO0lBQ1I7SUFDQTtJQUhWLFlBQ2tCLFNBQW9CLEVBQzVCLFNBQTJCLEVBQzNCLFVBQXNCO1FBRmQsY0FBUyxHQUFULFNBQVMsQ0FBVztRQUM1QixjQUFTLEdBQVQsU0FBUyxDQUFrQjtRQUMzQixlQUFVLEdBQVYsVUFBVSxDQUFZO0lBQzVCLENBQUM7SUFFTCxRQUFRO1FBRU4sTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUM7UUFFdkMsSUFBSSxDQUFDLE9BQU87WUFDVixPQUFPO1FBRVQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUUzSCxDQUFDO0lBRU8sVUFBVSxDQUFDLEtBQVU7UUFFM0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUMxQixPQUFPO1FBQ1QsQ0FBQztRQUVELEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7WUFFekIsSUFBSSxDQUFDLENBQUMsSUFBSSxZQUFZLElBQUksQ0FBQyxFQUFFLENBQUM7Z0JBQzVCLFNBQVM7WUFDWCxDQUFDO1lBRUQsSUFBSSxPQUFRLElBQVksQ0FBQyxNQUFNLEtBQUssVUFBVSxFQUFFLENBQUM7Z0JBQy9DLFNBQVM7WUFDWCxDQUFDO1lBRUQsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsUUFBUSxFQUFFO2dCQUNwQyxLQUFLO29CQUNILE9BQU87d0JBQ0wsR0FBRyxJQUFJO3dCQUNQLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTt3QkFDZixJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUk7d0JBQ2YsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO3dCQUNmLFlBQVksRUFBRSxJQUFJLENBQUMsWUFBWTtxQkFDaEMsQ0FBQztnQkFDSixDQUFDO2dCQUNELFFBQVEsRUFBRSxJQUFJO2dCQUNkLFlBQVksRUFBRSxJQUFJO2dCQUNsQixVQUFVLEVBQUUsS0FBSzthQUNsQixDQUFDLENBQUM7UUFDTCxDQUFDO0lBQ0gsQ0FBQzt3R0FsRFUsaUJBQWlCOzRGQUFqQixpQkFBaUI7OzRGQUFqQixpQkFBaUI7a0JBSjdCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHVCQUF1QjtvQkFDakMsVUFBVSxFQUFFLElBQUk7aUJBQ2pCOzswQkFJSSxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGVzdHJveVJlZiwgRGlyZWN0aXZlLCBPbkluaXQsIFNlbGYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTmdDb250cm9sIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBTdWJzY3JpYmVTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvc3Vic2NyaWJlLnNlcnZpY2UnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgc2VsZWN0b3I6ICduZ3gtc2lyaW8tZmlsZS11cGxvYWQnLFxyXG4gIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIEpzb25GaWxlRGlyZWN0aXZlIGltcGxlbWVudHMgT25Jbml0IHtcclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBAU2VsZigpIHByaXZhdGUgbmdDb250cm9sOiBOZ0NvbnRyb2wsXHJcbiAgICBwcml2YXRlIHN1YnNjcmliZTogU3Vic2NyaWJlU2VydmljZSxcclxuICAgIHByaXZhdGUgZGVzdHJveVJlZjogRGVzdHJveVJlZlxyXG4gICkgeyB9XHJcblxyXG4gIG5nT25Jbml0KCk6IHZvaWQge1xyXG5cclxuICAgIGNvbnN0IGNvbnRyb2wgPSB0aGlzLm5nQ29udHJvbC5jb250cm9sO1xyXG5cclxuICAgIGlmICghY29udHJvbClcclxuICAgICAgcmV0dXJuO1xyXG5cclxuICAgIHRoaXMuc3Vic2NyaWJlLnN1YnNjcmliZUNoYW5nZXMoY29udHJvbC52YWx1ZUNoYW5nZXMsIGNvbnRyb2wsIHVuZGVmaW5lZCwgdGhpcy5kZXN0cm95UmVmLCAoXywgbikgPT4gdGhpcy5kZWZpbmVKc29uKG4pKTtcclxuXHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGRlZmluZUpzb24odmFsdWU6IGFueSk6IHZvaWQge1xyXG5cclxuICAgIGlmICghQXJyYXkuaXNBcnJheSh2YWx1ZSkpIHtcclxuICAgICAgcmV0dXJuO1xyXG4gICAgfVxyXG5cclxuICAgIGZvciAoY29uc3QgaXRlbSBvZiB2YWx1ZSkge1xyXG5cclxuICAgICAgaWYgKCEoaXRlbSBpbnN0YW5jZW9mIEZpbGUpKSB7XHJcbiAgICAgICAgY29udGludWU7XHJcbiAgICAgIH1cclxuXHJcbiAgICAgIGlmICh0eXBlb2YgKGl0ZW0gYXMgYW55KS50b0pTT04gPT09ICdmdW5jdGlvbicpIHtcclxuICAgICAgICBjb250aW51ZTtcclxuICAgICAgfVxyXG5cclxuICAgICAgT2JqZWN0LmRlZmluZVByb3BlcnR5KGl0ZW0sICd0b0pTT04nLCB7XHJcbiAgICAgICAgdmFsdWUoKSB7XHJcbiAgICAgICAgICByZXR1cm4ge1xyXG4gICAgICAgICAgICAuLi50aGlzLFxyXG4gICAgICAgICAgICBuYW1lOiB0aGlzLm5hbWUsXHJcbiAgICAgICAgICAgIHNpemU6IHRoaXMuc2l6ZSxcclxuICAgICAgICAgICAgdHlwZTogdGhpcy50eXBlLFxyXG4gICAgICAgICAgICBsYXN0TW9kaWZpZWQ6IHRoaXMubGFzdE1vZGlmaWVkXHJcbiAgICAgICAgICB9O1xyXG4gICAgICAgIH0sXHJcbiAgICAgICAgd3JpdGFibGU6IHRydWUsXHJcbiAgICAgICAgY29uZmlndXJhYmxlOiB0cnVlLFxyXG4gICAgICAgIGVudW1lcmFibGU6IGZhbHNlXHJcbiAgICAgIH0pO1xyXG4gICAgfVxyXG4gIH1cclxuICAgIFxyXG59XHJcbiJdfQ==