@sapphire-ion/framework 0.30.0

package/esm2022/lib/pipes/secure.pipe.mjs

@@ -0,0 +1,42 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { from, switchMap } from 'rxjs';
+import { Pipe } from '@angular/core';
+import { ApiUrlProviderService } from '../services/web/api-url-provider.service';
+import { AuthService } from '../services/auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/auth.service";
+import * as i3 from "../services/web/api-url-provider.service";
+export class SecurePipe {
+    constructor(http, auth, apiUrlProviderService) {
+        this.http = http;
+        this.auth = auth;
+        this.apiUrlProviderService = apiUrlProviderService;
+    }
+    transform(src) {
+        if (src.startsWith(this.apiUrlProviderService.apiUrl)) {
+            // Convert the Promise to an Observable and chain the HTTP request
+            return from(this.auth.LoadToken())
+                .pipe(switchMap((Bearer) => {
+                const headers = new HttpHeaders({ 'Authorization': `Bearer ${Bearer}` });
+                return this.http.get(src, { headers, responseType: 'blob' });
+            }), switchMap((blob) => {
+                const url = URL.createObjectURL(blob);
+                return from(Promise.resolve(url));
+            }));
+        }
+        else {
+            return Promise.resolve(src);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurePipe, deps: [{ token: i1.HttpClient }, { token: i2.AuthService }, { token: i3.ApiUrlProviderService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: SecurePipe, isStandalone: true, name: "secure" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SecurePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'secure',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.AuthService }, { type: i3.ApiUrlProviderService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,149 @@
+import { firstValueFrom } from 'rxjs';
+import { NavController } from '@ionic/angular';
+import { Preferences } from '@capacitor/preferences';
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { jwtDecode } from 'jwt-decode';
+import { ApiUrlProviderService } from '../services/web/api-url-provider.service';
+import { EnvironmentService } from './environment.service';
+import { Utils } from './utils.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@ionic/angular";
+import * as i3 from "./environment.service";
+import * as i4 from "../services/web/api-url-provider.service";
+export class AuthService {
+    constructor(http, navController, coreService, apiUrlProviderService) {
+        this.http = http;
+        this.navController = navController;
+        this.coreService = coreService;
+        this.apiUrlProviderService = apiUrlProviderService;
+        this.localUserKey = this.coreService.environment.applicationName.toUpperCase() + "_USER_KEY";
+        this.localAdminKey = this.coreService.environment.applicationName.toUpperCase() + "_ADMIN_KEY";
+        this.currentToken = null;
+        this._isAdmin = false;
+        this.SetToken();
+    }
+    async SetToken() {
+        const Token = await this.LoadToken();
+        const TokenAdmin = await this.LoadTokenAdmin();
+        if (this.isTokenValid(Token)) {
+            this.currentToken = await this.JWToken();
+        }
+        else {
+            return this.Loggout();
+        }
+        if (TokenAdmin && this.isTokenValid(TokenAdmin)) {
+            this._isAdmin = true;
+        }
+        return;
+    }
+    async Loggout() {
+        await Preferences.remove({ key: this.localUserKey });
+        await Preferences.remove({ key: this.localAdminKey });
+        this.currentToken = null;
+        this.navController.navigateRoot("login");
+    }
+    get isAdmin() { return this._isAdmin; }
+    async Login(credentials) {
+        try {
+            const JWToken = await firstValueFrom(this.ApiLogin(credentials));
+            await this.SaveToken(JWToken);
+            await this.SetToken();
+            return (jwtDecode(JWToken));
+        }
+        catch (Error) {
+            throw Error;
+        }
+    }
+    async BypassLogin(id) {
+        try {
+            const JWToken = await firstValueFrom(this.ApiBypassLogin(id));
+            await this.SaveToken(JWToken);
+            await this.SetToken();
+            return (jwtDecode(JWToken));
+        }
+        catch (Error) {
+            throw Error;
+        }
+    }
+    ApiLogin(credentials) {
+        return this.http.post(this.apiUrlProviderService.apiUrl + 'auth', credentials);
+    }
+    ApiBypassLogin(id) {
+        return this.http.get(this.apiUrlProviderService.apiUrl + `auth/${id}`);
+    }
+    async SaveToken(JWToken) {
+        if (jwtDecode(JWToken).id == 1) {
+            await Preferences.set({ key: this.localAdminKey, value: JWToken });
+        }
+        await Preferences.set({ key: this.localUserKey, value: JWToken });
+    }
+    async LoadToken() {
+        const JWToken = (await Preferences.get({ key: this.localUserKey })).value;
+        if (JWToken) {
+            const ParsedObject = jwtDecode(JWToken);
+            return ParsedObject;
+        }
+        else {
+            return null;
+        }
+    }
+    async LoadTokenAdmin() {
+        const JWToken = (await Preferences.get({ key: this.localAdminKey })).value;
+        if (JWToken) {
+            const ParsedObject = jwtDecode(JWToken);
+            return ParsedObject;
+        }
+        else {
+            return null;
+        }
+    }
+    async JWToken() {
+        const JWToken = (await Preferences.get({ key: this.localUserKey })).value;
+        return JWToken;
+    }
+    async GetBearer() {
+        return `Bearer ${await this.JWToken()}`;
+    }
+    isTokenValid(Token) {
+        if (!Token) {
+            return false;
+        }
+        else
+            return !(Utils.UNIXToDate(Token.exp) < new Date());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, deps: [{ token: i1.HttpClient }, { token: i2.NavController }, { token: i3.EnvironmentService }, { token: i4.ApiUrlProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.NavController }, { type: i3.EnvironmentService }, { type: i4.ApiUrlProviderService }] });
+class Authentication {
+    constructor() {
+        this.Apelido = null;
+        this.Senha = null;
+    }
+}
+class Token {
+    constructor() {
+        this.Acesso = 0;
+        this.Apelido = "";
+        this.Nome = "";
+        this.id = 0;
+        this.idEmpresa = 0;
+    }
+    patch(token) {
+        for (let prop of Object.getOwnPropertyNames(token)) {
+            if (Number((token[prop]))) {
+                this[prop] = Number(token[prop]);
+                continue;
+            }
+            this[prop] = token[prop];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../projects/sapphire-ion-framework/src/lib/services/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, firstValueFrom } from 'rxjs';\r\nimport { NavController } from '@ionic/angular';\r\nimport { Preferences } from '@capacitor/preferences';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { jwtDecode } from 'jwt-decode';\r\n\r\nimport { ApiUrlProviderService } from '../services/web/api-url-provider.service';\r\nimport { EnvironmentService } from './environment.service';\r\nimport { Utils } from './utils.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuthService {\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private navController: NavController,\r\n    private coreService: EnvironmentService,\r\n    private apiUrlProviderService: ApiUrlProviderService \r\n  ) {\r\n    this.SetToken();\r\n  }\r\n\r\n  private localUserKey      : string = this.coreService.environment.applicationName.toUpperCase() + \"_USER_KEY\";\r\n  private localAdminKey     : string = this.coreService.environment.applicationName.toUpperCase() + \"_ADMIN_KEY\";\r\n  public  currentToken: string | null = null;\r\n\r\n  async SetToken(): Promise<void> {\r\n    const Token      = await this.LoadToken();\r\n    const TokenAdmin = await this.LoadTokenAdmin();\r\n    if(this.isTokenValid(Token)){\r\n      this.currentToken = await this.JWToken();\r\n    }else{\r\n      return this.Loggout();\r\n    }\r\n\r\n    if(TokenAdmin && this.isTokenValid(TokenAdmin)){\r\n      this._isAdmin = true;\r\n    }\r\n\r\n    return;\r\n  }\r\n\r\n  async Loggout(): Promise<void> {\r\n    await Preferences.remove({ key: this.localUserKey });\r\n    await Preferences.remove({ key: this.localAdminKey });\r\n    this.currentToken = null;\r\n    this.navController.navigateRoot(\"login\");\r\n  }\r\n  \r\n  _isAdmin: boolean = false;\r\n  get isAdmin(){ return this._isAdmin;  }\r\n\r\n  async Login(credentials: Authentication): Promise<any> {\r\n    try{\r\n      const JWToken = await firstValueFrom(this.ApiLogin(credentials));\r\n      await this.SaveToken(JWToken);\r\n      await this.SetToken();\r\n      return (jwtDecode(JWToken));\r\n    }\r\n    catch (Error){\r\n      throw Error;\r\n    }\r\n  }\r\n\r\n  async BypassLogin(id: number): Promise<any> {\r\n    try{\r\n      const JWToken = await firstValueFrom(this.ApiBypassLogin(id));\r\n      await this.SaveToken(JWToken);\r\n      await this.SetToken();\r\n      return (jwtDecode(JWToken));\r\n    }\r\n    catch (Error){\r\n      throw Error;\r\n    }\r\n  }\r\n\r\n  ApiLogin(credentials: Authentication): Observable<string> {\r\n    return this.http.post<string>(this.apiUrlProviderService.apiUrl + 'auth', credentials);\r\n  }\r\n  ApiBypassLogin(id: number): Observable<string> {\r\n    return this.http.get<string>(this.apiUrlProviderService.apiUrl + `auth/${id}`);\r\n  }\r\n\r\n  async SaveToken(JWToken: string): Promise<void>{\r\n    if((jwtDecode(JWToken) as Token).id == 1){ \r\n      await Preferences.set({ key: this.localAdminKey, value: JWToken});\r\n    }\r\n    await Preferences.set({ key: this.localUserKey, value: JWToken })\r\n  }\r\n\r\n  async LoadToken(): Promise<Token | null | any> {\r\n    const JWToken = (await Preferences.get({ key: this.localUserKey})).value;\r\n    if(JWToken){\r\n      const ParsedObject = jwtDecode(JWToken);\r\n      return ParsedObject;\r\n    }else{\r\n      return null;\r\n    }\r\n  }\r\n  async LoadTokenAdmin(): Promise<Token | null | any> {\r\n    const JWToken = (await Preferences.get({ key: this.localAdminKey})).value;\r\n    if(JWToken){\r\n      const ParsedObject = jwtDecode(JWToken);\r\n      return ParsedObject;\r\n    }else{\r\n      return null;\r\n    }\r\n  }\r\n\r\n  async JWToken(): Promise<string> {\r\n    const JWToken: string = (await Preferences.get({ key: this.localUserKey })).value;\r\n    return JWToken;\r\n  }\r\n\r\n  async GetBearer(): Promise<string>{\r\n    return `Bearer ${await this.JWToken()}`\r\n  }\r\n\r\n  public isTokenValid(Token: any): boolean{\r\n    if(!Token){ return false; }else\r\n    return !(Utils.UNIXToDate(Token.exp) < new Date())\r\n  }\r\n}\r\n\r\nclass Authentication{\r\n  public Apelido: string = null;\r\n  public Senha  : string = null;\r\n}\r\n\r\nclass Token {\r\n  [prop: string]: any;\r\n  Acesso   : number = 0;\r\n  Apelido  : string = \"\";\r\n  Nome     : string = \"\";\r\n  id       : number = 0;\r\n  idEmpresa: number = 0;\r\n  \r\n  constructor(){}\r\n  \r\n  patch(token: Token | any): void{\r\n    for(let prop of Object.getOwnPropertyNames(token)){\r\n      if(Number((token[prop]))){\r\n        this[prop] = Number(token[prop]); \r\n        continue;\r\n      }\r\n      this[prop] = token[prop];\r\n    }\r\n  }\r\n}"]}

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

@@ -0,0 +1,26 @@
+import { Inject, Injectable } from "@angular/core";
+import { EnvironmentInjectionToken } from "../core.module";
+import { Environment } from "../classes/environment";
+import * as i0 from "@angular/core";
+import * as i1 from "../classes/environment";
+export class EnvironmentService {
+    constructor(config) {
+        this.config = config;
+        this._environment = this.config;
+    }
+    get environment() {
+        return this._environment;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService, deps: [{ token: EnvironmentInjectionToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Environment, decorators: [{
+                    type: Inject,
+                    args: [EnvironmentInjectionToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NhcHBoaXJlLWlvbi1mcmFtZXdvcmsvc3JjL2xpYi9zZXJ2aWNlcy9lbnZpcm9ubWVudC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzNELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7O0FBS3JELE1BQU0sT0FBTyxrQkFBa0I7SUFDM0IsWUFBdUQsTUFBbUI7UUFBbkIsV0FBTSxHQUFOLE1BQU0sQ0FBYTtRQUN0RSxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDcEMsQ0FBQztJQUdELElBQUksV0FBVztRQUNYLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQztJQUM3QixDQUFDOytHQVJRLGtCQUFrQixrQkFDUCx5QkFBeUI7bUhBRHBDLGtCQUFrQixjQUZmLE1BQU07OzRGQUVULGtCQUFrQjtrQkFIOUIsVUFBVTttQkFBQztvQkFDUixVQUFVLEVBQUUsTUFBTTtpQkFDckI7OzBCQUVnQixNQUFNOzJCQUFDLHlCQUF5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IEVudmlyb25tZW50SW5qZWN0aW9uVG9rZW4gfSBmcm9tIFwiLi4vY29yZS5tb2R1bGVcIjtcclxuaW1wb3J0IHsgRW52aXJvbm1lbnQgfSBmcm9tIFwiLi4vY2xhc3Nlcy9lbnZpcm9ubWVudFwiO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBFbnZpcm9ubWVudFNlcnZpY2Uge1xyXG4gICAgY29uc3RydWN0b3IoQEluamVjdChFbnZpcm9ubWVudEluamVjdGlvblRva2VuKSBwcml2YXRlIGNvbmZpZzogRW52aXJvbm1lbnQpIHtcclxuICAgICAgICB0aGlzLl9lbnZpcm9ubWVudCA9IHRoaXMuY29uZmlnO1xyXG4gICAgfVxyXG5cclxuICAgIHByaXZhdGUgX2Vudmlyb25tZW50OiBFbnZpcm9ubWVudFxyXG4gICAgZ2V0IGVudmlyb25tZW50KCk6IEVudmlyb25tZW50e1xyXG4gICAgICAgIHJldHVybiB0aGlzLl9lbnZpcm9ubWVudDtcclxuICAgIH1cclxufSJdfQ==

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

@@ -0,0 +1,84 @@
+import { Injectable } from "@angular/core";
+import { Title } from '@angular/platform-browser';
+import { AlertController, ToastController } from "@ionic/angular";
+import { EnvironmentService } from './environment.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "./environment.service";
+export class GenericService {
+    constructor(toastController, alertController, titleController, coreService) {
+        this.toastController = toastController;
+        this.alertController = alertController;
+        this.titleController = titleController;
+        this.coreService = coreService;
+    }
+    async PresentToast(message, icon = 'alert-circle') {
+        const toast = await this.toastController.create({
+            message: message,
+            duration: 1750,
+            icon: icon,
+            position: 'bottom',
+            translucent: false,
+        });
+        await toast.present();
+    }
+    async PresentToastSuccess(message = "Salvo com sucesso!") {
+        const toast = await this.toastController.create({
+            message: message,
+            duration: 1750,
+            icon: 'checkmark-circle',
+            position: 'bottom',
+            translucent: false,
+        });
+        await toast.present();
+        return toast.onDidDismiss();
+    }
+    static { this.CancelButton = {
+        text: 'Cancelar',
+        role: 'cancel',
+    }; }
+    static { this.ConfirmButton = {
+        text: 'OK',
+        role: 'confirm',
+    }; }
+    static { this.defaultAlertButtons = [GenericService.ConfirmButton]; }
+    async PresentAlert(header, message, buttons = GenericService.defaultAlertButtons) {
+        const alert = await this.alertController.create({
+            header: header,
+            message: message,
+            buttons: buttons,
+        });
+        await alert.present();
+        return alert.onDidDismiss();
+    }
+    SetTitle(title) {
+        this.titleController.setTitle(this.coreService.environment.applicationName + " | " + title);
+    }
+    GetId(activatedRoute, depth = 2) {
+        try {
+            var Route = activatedRoute;
+            for (let i = 0; i < depth; i++) {
+                Route = Route.parent;
+            }
+            if (Route.snapshot.paramMap.has('id')) {
+                return Number(Route.snapshot.paramMap.get('id'));
+            }
+            else {
+                return 0;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GenericService, deps: [{ token: i1.ToastController }, { token: i1.AlertController }, { token: i2.Title }, { token: i3.EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GenericService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GenericService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ToastController }, { type: i1.AlertController }, { type: i2.Title }, { type: i3.EnvironmentService }] });
+//# 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUuY2FjaGUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NhcHBoaXJlLWlvbi1mcmFtZXdvcmsvc3JjL2xpYi9zZXJ2aWNlcy9yb3V0ZS9yb3V0ZS5jYWNoZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxpQkFBaUI7SUFBOUI7UUFDVSxlQUFVLEdBQWtCLElBQUksQ0FBQztJQWEzQyxDQUFDO0lBWEMsYUFBYTtRQUNYLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztJQUN6QixDQUFDO0lBRUQsYUFBYSxDQUFDLElBQVk7UUFDeEIsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUM7SUFDekIsQ0FBQztJQUVELFlBQVk7UUFDVixPQUFPLElBQUksQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDO0lBQ2pDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1lbnUgfSBmcm9tIFwiLi4vLi4vY29tcG9uZW50cy9kcmF3ZXIvbWVudVwiO1xyXG5cclxuZXhwb3J0IGNsYXNzIFJvdXRlQ2FjaGVTZXJ2aWNlIHtcclxuICBwcml2YXRlIGNhY2hlZERhdGE6IE1lbnVbXSB8IG51bGwgPSBudWxsO1xyXG5cclxuICBnZXRDYWNoZWREYXRhKCk6IE1lbnVbXSB7XHJcbiAgICByZXR1cm4gdGhpcy5jYWNoZWREYXRhO1xyXG4gIH1cclxuXHJcbiAgc2V0Q2FjaGVkRGF0YShkYXRhOiBNZW51W10pOiB2b2lkIHtcclxuICAgIHRoaXMuY2FjaGVkRGF0YSA9IGRhdGE7XHJcbiAgfVxyXG5cclxuICBpc0RhdGFDYWNoZWQoKTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdGhpcy5jYWNoZWREYXRhICE9IG51bGw7XHJcbiAgfVxyXG59Il19

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.13", ngImport: i0, type: RouteProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RouteProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RouteProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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 './generics.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 "./generics.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.13", 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.13", ngImport: i0, type: UsuarioService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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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