@sapphire-ion/framework 1.2.43 → 1.2.44

package/esm2022/lib/services/modal-focus-trap.service.mjs

@@ -0,0 +1,62 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Corrige o focus trap em modais do Ionic, permite que o foco não fique preso dentro do modal.
+ * Utilizado para concertar interatividade com popovers e outros elementos que podem ser interativos fora do modal.
+ */
+export class ModalFocusTrapService {
+    constructor() {
+        this.initGlobalFocusTrapDisable();
+    }
+    initGlobalFocusTrapDisable() {
+        // Wait for the platform to be ready
+        document.addEventListener('DOMContentLoaded', () => {
+            this.setupModalObserver();
+        });
+    }
+    setupModalObserver() {
+        // Create a mutation observer to watch for new modals
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                mutation.addedNodes.forEach((node) => {
+                    if (node.nodeType === Node.ELEMENT_NODE) {
+                        const element = node;
+                        // Check if the added node is an ion-modal
+                        if (element.tagName?.toLowerCase() === 'ion-modal') {
+                            this.disableFocusTrap(element);
+                        }
+                        // Check for ion-modal children
+                        const modals = element.querySelectorAll?.('ion-modal');
+                        modals?.forEach(modal => this.disableFocusTrap(modal));
+                    }
+                });
+            });
+        });
+        // Start observing
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true
+        });
+        // Also handle existing modals
+        const existingModals = document.querySelectorAll('ion-modal');
+        existingModals.forEach(modal => this.disableFocusTrap(modal));
+    }
+    disableFocusTrap(modal) {
+        // Add the CSS class
+        modal.classList.add('ion-disable-focus-trap');
+        // Set the property if it exists
+        const modalElement = modal;
+        if (modalElement.disableFocusTrap !== undefined) {
+            modalElement.disableFocusTrap = true;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModalFocusTrapService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModalFocusTrapService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ModalFocusTrapService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/popover-focus-trap.service.mjs

@@ -0,0 +1,62 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Corrige o focus trap em modais do Ionic, permite que o foco não fique preso dentro do popover.
+ * Utilizado para concertar interatividade com popovers e outros elementos que podem ser interativos fora do popover.
+ */
+export class PopoverFocusTrapService {
+    constructor() {
+        this.initGlobalFocusTrapDisable();
+    }
+    initGlobalFocusTrapDisable() {
+        // Wait for the platform to be ready
+        document.addEventListener('DOMContentLoaded', () => {
+            this.setuppopoverObserver();
+        });
+    }
+    setuppopoverObserver() {
+        // Create a mutation observer to watch for new popovers
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                mutation.addedNodes.forEach((node) => {
+                    if (node.nodeType === Node.ELEMENT_NODE) {
+                        const element = node;
+                        // Check if the added node is an ion-popover
+                        if (element.tagName?.toLowerCase() === 'ion-popover') {
+                            this.disableFocusTrap(element);
+                        }
+                        // Check for ion-popover children
+                        const popovers = element.querySelectorAll?.('ion-popover');
+                        popovers?.forEach(popover => this.disableFocusTrap(popover));
+                    }
+                });
+            });
+        });
+        // Start observing
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true
+        });
+        // Also handle existing popovers
+        const existingpopovers = document.querySelectorAll('ion-popover');
+        existingpopovers.forEach(popover => this.disableFocusTrap(popover));
+    }
+    disableFocusTrap(popover) {
+        // Add the CSS class
+        popover.classList.add('ion-disable-focus-trap');
+        // Set the property if it exists
+        const popoverElement = popover;
+        if (popoverElement.disableFocusTrap !== undefined) {
+            popoverElement.disableFocusTrap = true;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopoverFocusTrapService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopoverFocusTrapService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopoverFocusTrapService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/route/route.cache.service.mjs

@@ -0,0 +1,15 @@
+export class RouteCacheService {
+    constructor() {
+        this.cachedData = null;
+    }
+    getCachedData() {
+        return this.cachedData;
+    }
+    setCachedData(data) {
+        this.cachedData = data;
+    }
+    isDataCached() {
+        return this.cachedData != null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuY2FjaGUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvcm91dGUvcm91dGUuY2FjaGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8saUJBQWlCO0lBQTlCO1FBQ1UsZUFBVSxHQUFrQixJQUFJLENBQUM7SUFhM0MsQ0FBQztJQVhDLGFBQWE7UUFDWCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUM7SUFDekIsQ0FBQztJQUVELGFBQWEsQ0FBQyxJQUFZO1FBQ3hCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDO0lBQ3pCLENBQUM7SUFFRCxZQUFZO1FBQ1YsT0FBTyxJQUFJLENBQUMsVUFBVSxJQUFJLElBQUksQ0FBQztJQUNqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNZW51IH0gZnJvbSBcIi4uLy4uL2NvbXBvbmVudHMvZHJhd2VyL21lbnVcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBSb3V0ZUNhY2hlU2VydmljZSB7XHJcbiAgcHJpdmF0ZSBjYWNoZWREYXRhOiBNZW51W10gfCBudWxsID0gbnVsbDtcclxuXHJcbiAgZ2V0Q2FjaGVkRGF0YSgpOiBNZW51W10ge1xyXG4gICAgcmV0dXJuIHRoaXMuY2FjaGVkRGF0YTtcclxuICB9XHJcblxyXG4gIHNldENhY2hlZERhdGEoZGF0YTogTWVudVtdKTogdm9pZCB7XHJcbiAgICB0aGlzLmNhY2hlZERhdGEgPSBkYXRhO1xyXG4gIH1cclxuXHJcbiAgaXNEYXRhQ2FjaGVkKCk6IGJvb2xlYW4ge1xyXG4gICAgcmV0dXJuIHRoaXMuY2FjaGVkRGF0YSAhPSBudWxsO1xyXG4gIH1cclxufSJdfQ==

package/esm2022/lib/services/route/route.provider.service.mjs

@@ -0,0 +1,42 @@
+import { Observable, tap, share, finalize } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { RouteCacheService } from './route.cache.service';
+import * as i0 from "@angular/core";
+export class RouteProviderService {
+    constructor() {
+        this.loadFrom = [];
+        this.routeCacheService = new RouteCacheService();
+        this.loading$ = null;
+    }
+    GetData() {
+        // If a request is already in progress, return that Observable
+        if (this.loading$) {
+            return this.loading$;
+        }
+        if (Array.isArray(this.loadFrom)) {
+            this.routeCacheService.setCachedData(this.loadFrom);
+        }
+        const cachedData = this.routeCacheService.getCachedData();
+        if (cachedData) {
+            return new Observable(observer => {
+                observer.next(cachedData);
+                observer.complete();
+            });
+        }
+        else {
+            // Store the loading Observable and make sure to reset it when it completes
+            this.loading$ = this.loadFrom.pipe(tap(data => this.routeCacheService.setCachedData(data)), finalize(() => this.loading$ = null), share() // Share the same subscription with multiple subscribers
+            );
+            return this.loading$;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RouteProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RouteProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RouteProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUucHJvdmlkZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvcm91dGUvcm91dGUucHJvdmlkZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3hELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBTTFELE1BQU0sT0FBTyxvQkFBb0I7SUFNL0I7UUFKQSxhQUFRLEdBQWdDLEVBQUUsQ0FBQztRQUNuQyxzQkFBaUIsR0FBc0IsSUFBSSxpQkFBaUIsRUFBRSxDQUFDO1FBQy9ELGFBQVEsR0FBOEIsSUFBSSxDQUFDO0lBRy9DLENBQUM7SUFJTCxPQUFPO1FBQ0wsOERBQThEO1FBQzlELElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ2xCLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUN2QixDQUFDO1FBRUQsSUFBRyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBQyxDQUFDO1lBQy9CLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ3RELENBQUM7UUFFRCxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsYUFBYSxFQUFFLENBQUM7UUFFMUQsSUFBSSxVQUFVLEVBQUUsQ0FBQztZQUNmLE9BQU8sSUFBSSxVQUFVLENBQUMsUUFBUSxDQUFDLEVBQUU7Z0JBQy9CLFFBQVEsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7Z0JBQzFCLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUN0QixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7YUFBTSxDQUFDO1lBQ04sMkVBQTJFO1lBQzNFLElBQUksQ0FBQyxRQUFRLEdBQUksSUFBSSxDQUFDLFFBQStCLENBQUMsSUFBSSxDQUN4RCxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQ3ZELFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQyxFQUNwQyxLQUFLLEVBQUUsQ0FBQyx3REFBd0Q7YUFDakUsQ0FBQztZQUVGLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUN2QixDQUFDO0lBQ0gsQ0FBQzsrR0F0Q1Usb0JBQW9CO21IQUFwQixvQkFBb0IsY0FGbkIsTUFBTTs7NEZBRVAsb0JBQW9CO2tCQUhoQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUsIHRhcCwgc2hhcmUsIGZpbmFsaXplIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IFJvdXRlQ2FjaGVTZXJ2aWNlIH0gZnJvbSAnLi9yb3V0ZS5jYWNoZS5zZXJ2aWNlJztcclxuaW1wb3J0IHsgTWVudSB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvZHJhd2VyL21lbnUnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgUm91dGVQcm92aWRlclNlcnZpY2UgIHtcclxuXHJcbiAgbG9hZEZyb206IE9ic2VydmFibGU8TWVudVtdPiB8IE1lbnVbXSA9IFtdO1xyXG4gIHByaXZhdGUgcm91dGVDYWNoZVNlcnZpY2U6IFJvdXRlQ2FjaGVTZXJ2aWNlID0gbmV3IFJvdXRlQ2FjaGVTZXJ2aWNlKCk7XHJcbiAgcHJpdmF0ZSBsb2FkaW5nJDogT2JzZXJ2YWJsZTxNZW51W10+IHwgbnVsbCA9IG51bGw7XHJcblxyXG4gIGNvbnN0cnVjdG9yKFxyXG4gICkgeyB9XHJcblxyXG4gIHJlc29sdmVyOiBQcm9taXNlPE1lbnVbXT5cclxuXHJcbiAgR2V0RGF0YSgpOiBPYnNlcnZhYmxlPE1lbnVbXT4ge1xyXG4gICAgLy8gSWYgYSByZXF1ZXN0IGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MsIHJldHVybiB0aGF0IE9ic2VydmFibGVcclxuICAgIGlmICh0aGlzLmxvYWRpbmckKSB7XHJcbiAgICAgIHJldHVybiB0aGlzLmxvYWRpbmckO1xyXG4gICAgfVxyXG5cclxuICAgIGlmKEFycmF5LmlzQXJyYXkodGhpcy5sb2FkRnJvbSkpe1xyXG4gICAgICB0aGlzLnJvdXRlQ2FjaGVTZXJ2aWNlLnNldENhY2hlZERhdGEodGhpcy5sb2FkRnJvbSk7XHJcbiAgICB9XHJcblxyXG4gICAgY29uc3QgY2FjaGVkRGF0YSA9IHRoaXMucm91dGVDYWNoZVNlcnZpY2UuZ2V0Q2FjaGVkRGF0YSgpO1xyXG5cclxuICAgIGlmIChjYWNoZWREYXRhKSB7XHJcbiAgICAgIHJldHVybiBuZXcgT2JzZXJ2YWJsZShvYnNlcnZlciA9PiB7XHJcbiAgICAgICAgb2JzZXJ2ZXIubmV4dChjYWNoZWREYXRhKTtcclxuICAgICAgICBvYnNlcnZlci5jb21wbGV0ZSgpO1xyXG4gICAgICB9KTtcclxuICAgIH0gZWxzZSB7XHJcbiAgICAgIC8vIFN0b3JlIHRoZSBsb2FkaW5nIE9ic2VydmFibGUgYW5kIG1ha2Ugc3VyZSB0byByZXNldCBpdCB3aGVuIGl0IGNvbXBsZXRlc1xyXG4gICAgICB0aGlzLmxvYWRpbmckID0gKHRoaXMubG9hZEZyb20gYXMgT2JzZXJ2YWJsZTxNZW51W10+KS5waXBlKFxyXG4gICAgICAgIHRhcChkYXRhID0+IHRoaXMucm91dGVDYWNoZVNlcnZpY2Uuc2V0Q2FjaGVkRGF0YShkYXRhKSksXHJcbiAgICAgICAgZmluYWxpemUoKCkgPT4gdGhpcy5sb2FkaW5nJCA9IG51bGwpLFxyXG4gICAgICAgIHNoYXJlKCkgLy8gU2hhcmUgdGhlIHNhbWUgc3Vic2NyaXB0aW9uIHdpdGggbXVsdGlwbGUgc3Vic2NyaWJlcnNcclxuICAgICAgKTtcclxuICAgICAgXHJcbiAgICAgIHJldHVybiB0aGlzLmxvYWRpbmckO1xyXG4gICAgfVxyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/lib/services/usuario.service.mjs

@@ -0,0 +1,49 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { FormBuilder, Validators } from '@angular/forms';
+import { NavController } from '@ionic/angular';
+import { InputStringConfiguration, InputStringType } from '../components/inputs/input-string/input-string.configuration';
+import { ApiUrlProviderService } from '../services/web/api-url-provider.service';
+import { HttpServiceAtivo } from '../services/web/http.ativo.service';
+import { GenericService } from './generic.service';
+import { TableField } from '../classes/inputs/table-field';
+import { InputType } from '../components/inputs/input-type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/forms";
+import * as i3 from "./generic.service";
+import * as i4 from "@ionic/angular";
+import * as i5 from "../services/web/api-url-provider.service";
+export class UsuarioService extends HttpServiceAtivo {
+    constructor(http, fb, genericService, navController, apiUrlProviderService) {
+        super(http, fb, genericService, navController, apiUrlProviderService);
+        this.http = http;
+        this.fb = fb;
+        this.genericService = genericService;
+        this.navController = navController;
+        this.apiUrlProviderService = apiUrlProviderService;
+        this.route = "usuario";
+        this.title = "Usuario";
+    }
+    get lstTableFields() {
+        var lst = [];
+        lst[0] = this.defaultId;
+        lst[1] = new TableField("Nome", "nome", this.fb.control(null, Validators.required), InputType.String);
+        lst[2] = new TableField("Apelido", "apelido", this.fb.control(null, Validators.required), InputType.String);
+        lst[3] = new TableField("Senha", "senha", this.fb.control(null, Validators.required), InputType.String);
+        lst[3].hiddenView = true;
+        lst[3].configuration = new InputStringConfiguration(InputStringType.Password);
+        lst[4] = this.defaultAtivo;
+        return lst;
+    }
+    ;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsuarioService, deps: [{ token: i1.HttpClient }, { token: i2.FormBuilder }, { token: i3.GenericService }, { token: i4.NavController }, { token: i5.ApiUrlProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsuarioService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UsuarioService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.FormBuilder }, { type: i3.GenericService }, { type: i4.NavController }, { type: i5.ApiUrlProviderService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/utils.service.mjs

@@ -0,0 +1,190 @@
+import { ActionSheetController } from '@ionic/angular';
+import { FilePicker } from '@capawesome/capacitor-file-picker';
+import { Camera, CameraResultType, CameraSource } from '@capacitor/camera';
+import { Injectable } from '@angular/core';
+import moment from 'moment';
+import { Buffer } from 'buffer';
+import mime from 'mime';
+import { Capacitor } from '@capacitor/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+export class UtilsService {
+    constructor(actionSheetController) {
+        this.actionSheetController = actionSheetController;
+    }
+    /** Retorna um array de arquivos de acordo com o tipo de configutação */
+    async SelectFile(configuration) {
+        let SelectType;
+        (function (SelectType) {
+            SelectType[SelectType["camera"] = 1] = "camera";
+            SelectType[SelectType["galery"] = 2] = "galery";
+            SelectType[SelectType["file"] = 3] = "file";
+            SelectType[SelectType["deny"] = 4] = "deny";
+        })(SelectType || (SelectType = {}));
+        const btnCamera = { text: 'Câmera', icon: 'camera', data: SelectType.camera };
+        const btnGalery = { text: 'Galeria', icon: 'image', data: SelectType.galery };
+        const btnFile = { text: 'Selecionar Arquivo', icon: 'document', data: SelectType.file };
+        const btnDeny = { text: 'Cancelar', icon: 'close-circle', data: SelectType.deny, role: 'cancel', };
+        const isApp = (!document.URL.startsWith('http') || document.URL.startsWith('http://localhost:8080'));
+        var lstBtn = [];
+        if (isApp) {
+            lstBtn.push(btnCamera);
+            lstBtn.push(btnGalery);
+        }
+        lstBtn.push(btnFile);
+        lstBtn.push(btnDeny);
+        var res;
+        if (lstBtn.length > 2) {
+            const actionSheet = await this.actionSheetController.create({ buttons: lstBtn });
+            actionSheet.present();
+            res = await actionSheet.onDidDismiss();
+        }
+        else {
+            res = { role: 'confirm', data: lstBtn[0].data };
+        }
+        if (['backdrop', 'cancel'].includes(res.role)) {
+            return;
+        }
+        if ([SelectType.camera, SelectType.galery].includes(res.data)) {
+            const Source = res.data == SelectType.camera ? CameraSource.Camera : CameraSource.Photos;
+            //const photo = await Camera.getPhoto({ resultType: CameraResultType.Uri, source: Source, quality: 100 });
+            console.error("[ TODO ]");
+            return null;
+        }
+        else {
+            const res = FilePicker.pickFiles({ types: configuration.types, limit: 1 });
+            const files = (await res).files;
+            return files.map(p => p.blob)[0];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UtilsService, deps: [{ token: i1.ActionSheetController }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UtilsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ActionSheetController }] });
+export class Utils {
+    /** Converte de unix para Date object */
+    static UNIXToDate(unix_timestamp) {
+        var date = new Date(unix_timestamp * 1000);
+        return date;
+    }
+    /**
+     * @param DateStr - Date on ISO format, e.g:
+     * [ 2010-10-05T14:48:00.000Z ]
+     * @returns Date on format DD/MM/YYYY
+    */
+    static DateISOToDDMMYYYYHHMM(iso, onInvalidDateString = '-') {
+        if (!iso) {
+            return onInvalidDateString;
+        }
+        return moment(iso).format("DD/MM/YYYY HH:mm");
+    }
+    /**
+       * @param iso - Date on ISO format, e.g:
+       * [ 2010-10-05T14:48:00.000Z ]
+       * @returns Date on format DD/MM/YYYY
+      */
+    static DateISOToDDMMYYYY(iso, onInvalidDateString = '-') {
+        if (!iso) {
+            return onInvalidDateString;
+        }
+        return moment(iso).format("DD/MM/YYYY");
+    }
+    static GenerateGUID() {
+        return 'id-xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    /**
+     * @param file: base64 | Blob
+     */
+    static async DownloadFile(file, fileName) {
+        var blob = null;
+        if (!(file instanceof Blob)) {
+            blob = await Utils.Base64ToBlob(file, Utils.FindMimeFromNameOrExtension(fileName));
+        }
+        else {
+            blob = file;
+        }
+        var fileURL = URL.createObjectURL(blob);
+        const linkElement = document.createElement("a");
+        linkElement.setAttribute("href", fileURL);
+        linkElement.setAttribute("target", "_blank");
+        linkElement.setAttribute("download", fileName);
+        let me = new MouseEvent("click", {
+            view: window,
+            bubbles: true,
+            cancelable: false,
+        });
+        linkElement.dispatchEvent(me);
+    }
+    static async BlobToBase64(blob) {
+        const ab = await blob.arrayBuffer();
+        return Buffer.from(ab).toString("base64");
+    }
+    static async Base64ToBlob(base64, mimeType) {
+        return new Blob([Buffer.from(base64, "base64")], { type: mimeType });
+    }
+    static async GetPhoto(params) {
+        const quality = params?.quality || 70;
+        const source = params?.source || CameraSource.Camera;
+        const ph = await Camera.getPhoto({
+            resultType: CameraResultType.Uri,
+            source: source,
+            quality: quality
+        });
+        const file = await fetch(ph.webPath);
+        const blob = await file.blob();
+        return { blob, fileName: ph.path.split('/').at(-1) };
+    }
+    static async PickFile(options) {
+        const Pick = await FilePicker.pickFiles(options);
+        let lstBlob = Pick.files.map(async (vFile) => {
+            let blob = null;
+            if (Capacitor.isNativePlatform()) {
+                blob = new Blob([await (await fetch(Capacitor.convertFileSrc(vFile.path))).blob()], { type: vFile.mimeType });
+            }
+            else {
+                blob = vFile.blob;
+            }
+            return {
+                blob,
+                mimeType: vFile.mimeType,
+                name: vFile.name,
+                size: vFile.size,
+            };
+        });
+        return Promise.all(lstBlob);
+    }
+    static FindMimeFromNameOrExtension(pathOrExtension) {
+        return mime.getType(pathOrExtension) || 'application/octet-stream';
+    }
+}
+export function Search(items, Search, bindLabel) {
+    return items.filter(p => bindLabel(p)?.toLowerCase().includes(Search.toLowerCase()));
+}
+export function Timeout(timeout) {
+    return new Promise(resolve => setTimeout(resolve, timeout));
+}
+//[ Base 64 ]
+function DecodeBase64(b64) {
+    return JSON.parse(Buffer.from(b64, 'base64').toString('utf-8'));
+}
+function DecodeBase64AsString(b64) {
+    return Buffer.from(b64, 'base64').toString('utf-8');
+}
+function EncodeBase64(obj) {
+    if (typeof obj == "object") {
+        return Buffer.from(JSON.stringify(obj)).toString('base64');
+    }
+    else if (typeof obj == "string") {
+        return Buffer.from(obj).toString('base64');
+    }
+}
+export const INT_MAX = 2_147_483_646;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../src/lib/services/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActionSheetButton, ActionSheetController } from '@ionic/angular';\r\nimport { FilePicker, PickFilesResult, PickedFile, PickFilesOptions } from '@capawesome/capacitor-file-picker';\r\nimport { Camera, CameraResultType, CameraSource } from '@capacitor/camera';\r\nimport { OverlayEventDetail } from '@ionic/core';\r\nimport { Injectable } from '@angular/core';\r\nimport moment from 'moment';\r\nimport { Buffer } from 'buffer';\r\nimport mime from 'mime';\r\nimport { InputFileConfiguration } from '../components/inputs/input-file/input-file.configuration';\r\nimport { Capacitor } from '@capacitor/core';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UtilsService{\r\n\r\n  constructor(private actionSheetController: ActionSheetController) {\r\n  }\r\n\r\n  /** Retorna um array de arquivos de acordo com o tipo de configutação */\r\n  async SelectFile(configuration: InputFileConfiguration): Promise<File>{\r\n    enum SelectType {\r\n      camera = 1,\r\n      galery = 2,\r\n      file   = 3,\r\n      deny   = 4,\r\n    }\r\n\r\n    const btnCamera: ActionSheetButton = { text: 'Câmera'            , icon: 'camera'      , data: SelectType.camera }\r\n    const btnGalery: ActionSheetButton = { text: 'Galeria'           , icon: 'image'       , data: SelectType.galery }\r\n    const btnFile  : ActionSheetButton = { text: 'Selecionar Arquivo', icon: 'document'    , data: SelectType.file   }\r\n    const btnDeny  : ActionSheetButton = { text: 'Cancelar'          , icon: 'close-circle', data: SelectType.deny, role: 'cancel', };\r\n\r\n    const isApp = (!document.URL.startsWith('http') || document.URL.startsWith('http://localhost:8080'));\r\n\r\n    var lstBtn: any[] = [];\r\n    if(isApp){ \r\n      lstBtn.push(btnCamera); \r\n      lstBtn.push(btnGalery);\r\n    }\r\n    lstBtn.push(btnFile);\r\n    lstBtn.push(btnDeny);\r\n\r\n    var res: OverlayEventDetail<any>;\r\n    if(lstBtn.length > 2){\r\n      const actionSheet = await this.actionSheetController.create({ buttons: lstBtn });\r\n      actionSheet.present();\r\n      res = await actionSheet.onDidDismiss();\r\n    }else{\r\n      res = { role: 'confirm', data: lstBtn[0].data };\r\n    }\r\n\r\n    \r\n    if(['backdrop', 'cancel'].includes(res.role)){ return; }\r\n\r\n    if([SelectType.camera, SelectType.galery].includes(res.data)){ \r\n      const Source = res.data == SelectType.camera ? CameraSource.Camera : CameraSource.Photos\r\n      //const photo = await Camera.getPhoto({ resultType: CameraResultType.Uri, source: Source, quality: 100 });\r\n      console.error(\"[ TODO ]\")\r\n      return null;\r\n    }else{\r\n      const res: Promise<PickFilesResult> = FilePicker.pickFiles({ types: configuration.types, limit: 1 });\r\n      const files: PickedFile[] = (await res).files;\r\n      return files.map(p => <File>p.blob)[0];\r\n    }\r\n  } \r\n}\r\n\r\nexport class Utils {\r\n  /** Converte de unix para Date object */\r\n  static UNIXToDate(unix_timestamp: number): Date {\r\n    var date = new Date(unix_timestamp * 1000);\r\n    return date;\r\n  }\r\n  \r\n  /**\r\n   * @param DateStr - Date on ISO format, e.g: \r\n   * [ 2010-10-05T14:48:00.000Z ]\r\n   * @returns Date on format DD/MM/YYYY\r\n  */\r\n  static DateISOToDDMMYYYYHHMM(iso: string, onInvalidDateString: string = '-'): string{\r\n    if(!iso){ return onInvalidDateString; }\r\n    return moment(iso).format(\"DD/MM/YYYY HH:mm\");\r\n  }\r\n\r\n  /**\r\n     * @param iso - Date on ISO format, e.g: \r\n     * [ 2010-10-05T14:48:00.000Z ]\r\n     * @returns Date on format DD/MM/YYYY\r\n    */\r\n  static DateISOToDDMMYYYY(iso: string, onInvalidDateString: string = '-'): string{\r\n    if(!iso){ return onInvalidDateString; }\r\n    return moment(iso).format(\"DD/MM/YYYY\");\r\n  }\r\n\r\n  static GenerateGUID(): string {\r\n    return 'id-xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\r\n      var r = Math.random() * 16 | 0,\r\n      v = c === 'x' ? r : (r & 0x3 | 0x8);\r\n      return v.toString(16);\r\n    });\r\n  }\r\n\r\n  /** \r\n   * @param file: base64 | Blob\r\n   */\r\n  static async DownloadFile(file: string | Blob, fileName: string){\r\n    var blob: Blob = null;\r\n    if(!(file instanceof Blob)){\r\n      blob = await Utils.Base64ToBlob(file, Utils.FindMimeFromNameOrExtension(fileName));\r\n    }\r\n    else{ \r\n      blob = file; \r\n    }\r\n\r\n    var fileURL = URL.createObjectURL(blob);\r\n    const linkElement = document.createElement(\"a\");\r\n    linkElement.setAttribute(\"href\", fileURL);\r\n    linkElement.setAttribute(\"target\", \"_blank\");\r\n    linkElement.setAttribute(\"download\", fileName);\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  }\r\n\r\n  public static async BlobToBase64(blob: Blob): Promise<string> {\r\n    const ab = await blob.arrayBuffer();\r\n    return Buffer.from(ab).toString(\"base64\");\r\n  }\r\n\r\n  public static async Base64ToBlob(base64: string, mimeType: string): Promise<Blob> {\r\n    return new Blob([Buffer.from(base64, \"base64\")], { type: mimeType })\r\n  }\r\n\r\n  public static async GetPhoto(params?: {\r\n    quality?: number,\r\n    source?: CameraSource\r\n  }): Promise<{\r\n    blob: Blob\r\n    fileName: string\r\n  }>{\r\n    const quality = params?.quality || 70;\r\n    const source  = params?.source || CameraSource.Camera;\r\n    const ph   = await Camera.getPhoto({ \r\n      resultType: CameraResultType.Uri, \r\n      source : source,\r\n      quality: quality\r\n    });\r\n    const file = await fetch(ph.webPath);\r\n    const blob = await file.blob();\r\n    return { blob, fileName: ph.path.split('/').at(-1) };\r\n  }\r\n\r\n  public static async PickFile(options?: PickFilesOptions): Promise<{\r\n    blob: Blob,\r\n    mimeType: string,\r\n    name: string,\r\n    size: number,\r\n  }[]> {\r\n    const Pick = await FilePicker.pickFiles(options);\r\n    let lstBlob = Pick.files.map(async vFile => {\r\n      let blob = null;\r\n      if(Capacitor.isNativePlatform()){\r\n        blob = new Blob([await (await fetch(Capacitor.convertFileSrc(vFile.path))).blob()], { type: vFile.mimeType });\r\n      }\r\n      else{\r\n        blob = vFile.blob;\r\n      }\r\n      return {\r\n        blob,\r\n        mimeType: vFile.mimeType,\r\n        name: vFile.name,\r\n        size: vFile.size,\r\n      };\r\n    });\r\n    return Promise.all(lstBlob);    \r\n  }\r\n\r\n  static FindMimeFromNameOrExtension(pathOrExtension: string){\r\n    return mime.getType(pathOrExtension) || 'application/octet-stream';\r\n  }\r\n}\r\n\r\nexport function Search<T = any>(items: T[], Search: string, bindLabel: ((obj: T) => string)): T[] {\r\n  return items.filter(p => bindLabel(p)?.toLowerCase().includes(Search.toLowerCase()));\r\n}\r\n\r\nexport function Timeout(timeout: number): Promise<void>{\r\n  return new Promise(resolve => setTimeout(resolve, timeout));\r\n}\r\n\r\n//[ Base 64 ]\r\nfunction DecodeBase64<T>(b64: string): T{\r\n  return JSON.parse(Buffer.from(b64, 'base64').toString('utf-8'));\r\n}\r\n\r\nfunction DecodeBase64AsString(b64: string) {\r\n  return Buffer.from(b64, 'base64').toString('utf-8');\r\n}\r\n\r\nfunction EncodeBase64(obj: any | string): string{\r\n  if(typeof obj == \"object\"){\r\n    return Buffer.from(JSON.stringify(obj)).toString('base64');\r\n  }\r\n  else\r\n  if(typeof obj == \"string\"){\r\n    return Buffer.from(obj).toString('base64');\r\n  }\r\n}\r\n\r\nexport const INT_MAX = 2_147_483_646;"]}

package/esm2022/lib/services/web/api-url-provider.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { EnvironmentService } from '../environment.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../environment.service";
+export class ApiUrlProviderService {
+    constructor(coreService) {
+        this.coreService = coreService;
+        //#region [ API URL ]
+        this._apiUrl = '';
+        this._production = coreService.environment.production;
+        this.apiUrl = this.coreService.environment.apiUrl;
+        ;
+        console.log(`%c [ @sapphire-ion/framework : ${this.coreService.environment.applicationName} started @ development ] | Conectado em: ${this.apiUrl}`, "background-color: #2fdf75; color: black;");
+    }
+    get apiUrl() { return this._apiUrl; }
+    set apiUrl(value) {
+        this._apiUrl = value;
+    }
+    get production() { return this._production; }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApiUrlProviderService, deps: [{ token: i1.EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApiUrlProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApiUrlProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.EnvironmentService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/web/http.ativo.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { InputBoolConfiguration, InputBoolType } from '../../components/inputs/input-bool/input-bool.configuration';
+import { HttpService } from './http.service';
+import { TableField } from '../../classes/inputs/table-field';
+import { InputType } from '../../components/inputs/input-type';
+import * as i0 from "@angular/core";
+export class HttpServiceAtivo extends HttpService {
+    /**
+     * Troca o status de ativo da entidade
+     */
+    Ativar(id) {
+        return this.http.post(this.fullRoute + `/ativar/${id}`, {});
+    }
+    /**
+     * Lista todos os dados ativos
+     * @param vFilter
+     */
+    ListAtivo(vFilter) {
+        return this.http.post(this.fullRoute + `/listAtivo`, vFilter);
+    }
+    /** Table Field padrão de ativo */
+    get defaultAtivo() {
+        var control = this.fb.control(true);
+        const field = new TableField("Ativo", "ativo", control, InputType.Bool);
+        field.configuration = new InputBoolConfiguration(InputBoolType.Toggle);
+        return field;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpServiceAtivo, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpServiceAtivo, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpServiceAtivo, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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