@sapphire-ion/framework 1.3.6 → 1.3.8

package/esm2022/lib/services/web/storage.service.mjs

@@ -0,0 +1,186 @@
+import { HttpClient, HttpEventType } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { ApiUrlProviderService } from './api-url-provider.service';
+import { GenericService } from '../generic.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./api-url-provider.service";
+import * as i3 from "../generic.service";
+export class StorageService {
+    constructor(http, apiUrlProviderService, genericService) {
+        this.http = http;
+        this.apiUrlProviderService = apiUrlProviderService;
+        this.genericService = genericService;
+        this.currentlyDownloading = [];
+    }
+    GetProgress(file) {
+        const Download = this.currentlyDownloading.find(p => p.file == file);
+        return Download ? Download.progress : 0;
+    }
+    StartDownload(file, params, post = false, fileName = null) {
+        if (!this.currentlyDownloading.find(p => p.file == file)) {
+            const download = new Download(file);
+            this.currentlyDownloading.push(download);
+            this.HandleDownload(download, params, post, fileName);
+            return download;
+        }
+        return this.currentlyDownloading.find(p => p.file == file);
+    }
+    HandleDownload(download, params, post = false, fileName = null) {
+        var request = this.GetFile(download.file, params, post);
+        const requestProgess = new BehaviorSubject(null);
+        download.requestProgess = requestProgess;
+        request.subscribe({
+            next: (event) => {
+                if (event.type === HttpEventType.DownloadProgress) {
+                    download.progress = event.loaded / event.total;
+                    requestProgess.next(download.progress);
+                }
+                else if (event.type === HttpEventType.Response) {
+                    DownloadFile(event, download.file, fileName);
+                    this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1);
+                    requestProgess.complete();
+                }
+                if (event.status == 404) {
+                    this.genericService.PresentToast("Arquivo não encontrado / Url inválida");
+                    requestProgess.error(event);
+                    requestProgess.complete();
+                }
+            },
+            error: (err) => {
+                this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1);
+            }
+        });
+        return request;
+    }
+    static SanitizeFileName(v) {
+        try {
+            var filenameEnd = v.split('/').at(-1);
+            if (filenameEnd.split('.').length <= 2) {
+                return filenameEnd;
+            }
+            else {
+                var lst = filenameEnd.split('.');
+                lst[0] = '';
+                return lst.join('.').replace('.', '');
+            }
+        }
+        catch {
+            return v;
+        }
+    }
+    ;
+    GetFile(fileUrl, params, post = false) {
+        var url;
+        if (fileUrl[0] == '/') {
+            url = fileUrl.slice(1, fileUrl.length - 1);
+        }
+        else {
+            url = `${this.apiUrlProviderService.apiUrl}${fileUrl}`;
+        }
+        url = encodeURI(url).replace(/#/g, '%23');
+        if (!post) {
+            return this.http.get(url, {
+                reportProgress: true,
+                observe: 'events',
+                responseType: 'blob',
+                params: params
+            });
+        }
+        else {
+            return this.http.post(url, params, {
+                reportProgress: true,
+                observe: 'events',
+                responseType: 'blob'
+            });
+        }
+    }
+    /**
+     * @param lstFiles
+     * lista de arquivos a serem baixados
+     * @param onUpdate
+     * funcao chamada a cada progresso de download
+     * @returns
+     * lista de respostas dos arquivos, como promise, quando todos estiverem completos ou deram erro, é retornada
+     */
+    async GetBlobBatchLiveResponse(lstFiles, onUpdate) {
+        if (!lstFiles || lstFiles.length === 0) {
+            return Promise.resolve([]);
+        }
+        const lst = lstFiles.map(p => ({
+            path: p,
+            observable: this.GetFile(p),
+            progress: 0,
+            success: undefined,
+            blob: undefined
+        }));
+        const isAllComplete = () => lst.every(obs => obs.progress >= 1);
+        const getTotalProgressAvg = () => lst.reduce((acc, obs) => acc + obs.progress, 0) / lst.length;
+        return new Promise((resolve) => {
+            for (const obs of lst) {
+                obs.observable.subscribe({
+                    next: (event) => {
+                        if (event.type === HttpEventType.DownloadProgress) {
+                            obs.progress = event.loaded / event.total;
+                            onUpdate(getTotalProgressAvg(), lst, event.type);
+                        }
+                        else if (event.type === HttpEventType.Response) {
+                            obs.blob = new Blob([event.body], { type: event.body.type });
+                            obs.success = true;
+                            if (isAllComplete()) {
+                                resolve(lst);
+                            }
+                            onUpdate(getTotalProgressAvg(), lst, event.type);
+                        }
+                    },
+                    error: (err) => {
+                        obs.success = false;
+                        obs.progress = 1;
+                        onUpdate(getTotalProgressAvg(), lst);
+                        if (isAllComplete()) {
+                            resolve(lst);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    async GetBlobLiveResponse(file, onUpdate) {
+        return (await this.GetBlobBatchLiveResponse([file], (totalProgress, lstResponse, eventType) => {
+            onUpdate?.(totalProgress, lstResponse[0], eventType);
+        }))[0];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: StorageService, deps: [{ token: i1.HttpClient }, { token: i2.ApiUrlProviderService }, { token: i3.GenericService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: StorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ApiUrlProviderService }, { type: i3.GenericService }] });
+export class Download {
+    constructor(file) {
+        this.file = file;
+        this.progress = 0.00001;
+    }
+}
+function DownloadFile(data, fileUrl, fileName = null) {
+    const downloadedFile = new Blob([data.body], { type: data.body.type });
+    var fileURL = URL.createObjectURL(downloadedFile);
+    const linkElement = document.createElement("a");
+    linkElement.setAttribute("href", fileURL);
+    linkElement.setAttribute("target", "_blank");
+    linkElement.setAttribute("download", StorageService.SanitizeFileName(fileUrl));
+    if (fileName) {
+        linkElement.setAttribute("download", fileName);
+    }
+    let me = new MouseEvent("click", {
+        view: window,
+        bubbles: true,
+        cancelable: false,
+    });
+    linkElement.dispatchEvent(me);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/web/storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpEvent, HttpEventType, HttpResponse } from '@angular/common/http';\r\nimport { BehaviorSubject, Observable, lastValueFrom, map, filter } from 'rxjs';\r\nimport { Injectable } from '@angular/core';\r\n\r\nimport { ApiUrlProviderService } from './api-url-provider.service';\r\nimport { GenericService } from '../generic.service';\r\nimport { Utils } from '../utils.service';\r\n\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class StorageService {\r\n\r\n  constructor(\r\n  private http : HttpClient,\r\n  private apiUrlProviderService: ApiUrlProviderService,\r\n  private genericService: GenericService\r\n  ) { }\r\n\r\n  private currentlyDownloading: Download[] = [];\r\n\r\n  public GetProgress(file: string): number{\r\n    const Download = this.currentlyDownloading.find(p => p.file == file)\r\n    return Download ? Download.progress : 0;\r\n  }\r\n\r\n  public StartDownload(file: string, params?: any, post: boolean = false, fileName : string | null = null): Download {\r\n    if(!this.currentlyDownloading.find(p => p.file == file)){\r\n      const download = new Download(file);\r\n      this.currentlyDownloading.push(download);\r\n      this.HandleDownload(download, params, post, fileName);\r\n      return download;\r\n    }\r\n    return this.currentlyDownloading.find(p => p.file == file);\r\n  }\r\n\r\n  private HandleDownload(download: Download, params?: any, post: boolean = false, fileName: string | null = null){\r\n    var request: Observable<any> = this.GetFile(download.file, params, post);\r\n\r\n    const requestProgess = new BehaviorSubject<any>(null);\r\n    download.requestProgess = requestProgess;\r\n    request.subscribe({\r\n      next: (event) => {\r\n        if (event.type === HttpEventType.DownloadProgress) { \r\n          download.progress = event.loaded / event.total; \r\n          requestProgess.next(download.progress);\r\n        } else \r\n        if (event.type === HttpEventType.Response) {\r\n          DownloadFile(event, download.file, fileName);\r\n          this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1);\r\n          requestProgess.complete(); \r\n        }\r\n        if(event.status == 404){\r\n          this.genericService.PresentToast(\"Arquivo não encontrado / Url inválida\")\r\n          requestProgess.error(event); \r\n          requestProgess.complete(); \r\n        }\r\n      },\r\n      error: (err) => {\r\n        this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1)\r\n      }\r\n    });\r\n    return request;\r\n  }\r\n\r\n  public static SanitizeFileName(v: string): string{\r\n    try{\r\n      var filenameEnd: string  = v.split('/').at(-1);\r\n      \r\n      if(filenameEnd.split('.').length <= 2){\r\n        return filenameEnd;\r\n      }else{\r\n        var lst = filenameEnd.split('.');\r\n        lst[0] = '';\r\n        return lst.join('.').replace('.', '');\r\n      }\r\n    }catch{\r\n      return v;\r\n    }\r\n  };\r\n\r\n  public GetFile(fileUrl: string, params?: any, post: boolean = false): Observable<HttpEvent<Blob>> {\r\n    var url: string;\r\n    if(fileUrl[0] == '/'){ \r\n      url = fileUrl.slice(1, fileUrl.length - 1);\r\n    }else{\r\n      url = `${this.apiUrlProviderService.apiUrl}${fileUrl}`;\r\n    }\r\n    url = encodeURI(url).replace(/#/g, '%23')\r\n\r\n    if(!post){\r\n      return this.http.get(url, {\r\n        reportProgress: true,\r\n        observe: 'events',\r\n        responseType: 'blob',\r\n        params: params\r\n      });\r\n    }else{\r\n      return this.http.post(url, params, {\r\n        reportProgress: true,\r\n        observe: 'events',\r\n        responseType: 'blob'\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @param lstFiles \r\n   * lista de arquivos a serem baixados \r\n   * @param onUpdate \r\n   * funcao chamada a cada progresso de download\r\n   * @returns \r\n   * lista de respostas dos arquivos, como promise, quando todos estiverem completos ou deram erro, é retornada\r\n   */\r\n  public async GetBlobBatchLiveResponse(lstFiles: string[], onUpdate: (totalProgress: number, lstResponse?: LiveResponse[], eventType?: HttpEventType) => void): Promise<LiveResponse[]> {\r\n    if(!lstFiles || lstFiles.length === 0) {\r\n      return Promise.resolve([]);\r\n    }\r\n\r\n    const lst: LiveResponse[] = lstFiles.map(p => ({\r\n      path      : p,\r\n      observable: this.GetFile(p),\r\n      progress  : 0,\r\n      success   : undefined,\r\n      blob      : undefined\r\n    }));\r\n\r\n    const isAllComplete = () => lst.every(obs => obs.progress >= 1);\r\n    const getTotalProgressAvg = () => lst.reduce((acc, obs) => acc + obs.progress, 0) / lst.length;\r\n\r\n    return new Promise<LiveResponse[]>((resolve) => {\r\n      for (const obs of lst) {\r\n        obs.observable.subscribe({\r\n          next: (event) => {\r\n            if (event.type === HttpEventType.DownloadProgress) {\r\n              obs.progress = event.loaded / event.total;\r\n              onUpdate(getTotalProgressAvg(), lst, event.type);\r\n            } \r\n            else\r\n            if (event.type === HttpEventType.Response) {\r\n              obs.blob = new Blob([event.body], { type: event.body.type });\r\n              obs.success = true;\r\n              if(isAllComplete()){\r\n                resolve(lst);\r\n              }\r\n              onUpdate(getTotalProgressAvg(), lst, event.type);\r\n            }\r\n          },\r\n          error: (err) => {\r\n            obs.success = false;\r\n            obs.progress = 1;\r\n            onUpdate(getTotalProgressAvg(), lst);\r\n            if(isAllComplete()){\r\n              resolve(lst);\r\n            }\r\n          }\r\n        });\r\n      }\r\n    })\r\n  }\r\n\r\n  public async GetBlobLiveResponse(file: string, onUpdate?: (progress: number, response?: LiveResponse, eventType?: HttpEventType) => void): Promise<LiveResponse> {\r\n    return (await this.GetBlobBatchLiveResponse([file], (totalProgress, lstResponse, eventType) => {\r\n      onUpdate?.(totalProgress, lstResponse[0], eventType);\r\n    }))[0];\r\n  }\r\n}\r\n\r\nexport interface GetFileResponse{\r\n  path: string;\r\n  blob?: Blob;\r\n}\r\n\r\nexport interface LiveResponse{\r\n  path: string;\r\n  observable: Observable<HttpEvent<Blob>>;\r\n  progress: number;\r\n  blob?: Blob;\r\n  success?: boolean;\r\n}\r\n\r\nexport class Download {\r\n  requestProgess: Observable<any>;\r\n  progress      : number = 0.00001;\r\n  constructor(public file: string){}\r\n}\r\n\r\nfunction DownloadFile(data: HttpResponse<Blob>, fileUrl, fileName: string | null = null) {\r\n  const downloadedFile = new Blob([data.body], { type: data.body.type });\r\n\r\n  var fileURL = URL.createObjectURL(downloadedFile);\r\n  const linkElement = document.createElement(\"a\");\r\n  linkElement.setAttribute(\"href\", fileURL);\r\n  linkElement.setAttribute(\"target\", \"_blank\");\r\n  linkElement.setAttribute(\"download\", StorageService.SanitizeFileName(fileUrl));\r\n\r\n  if(fileName) {\r\n      linkElement.setAttribute(\"download\", fileName);\r\n  }\r\n\r\n  let me = new MouseEvent(\"click\", {\r\n      view: window,\r\n      bubbles: true,\r\n      cancelable: false,\r\n  });\r\n\r\n  linkElement.dispatchEvent(me);\r\n}"]}

package/esm2022/public-api.mjs

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of ion-sapphire-framework
+ */
+export * from './lib/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgaW9uLXNhcHBoaXJlLWZyYW1ld29ya1xyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2luZGV4JzsiXX0=

package/esm2022/sapphire-ion-framework.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FwcGhpcmUtaW9uLWZyYW1ld29yay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zYXBwaGlyZS1pb24tZnJhbWV3b3JrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=