@sapphire-ion/framework 0.30.26 → 0.30.28

package/src/lib/components/stepper/stepper.component.ts

@@ -0,0 +1,36 @@
+import { AfterContentInit, Component, ContentChildren, QueryList } from '@angular/core';
+import { StepComponent } from './step/step.component';
+import { CustomInput } from '../inputs/custom-input';
+import { InputProviderFactory } from '../inputs/input-provider-factory';
+
+@Component({
+  selector: 'stepper',
+  templateUrl: './stepper.component.html',
+  styleUrls: ['./stepper.component.scss'],
+  providers: InputProviderFactory.GetProvider(StepperComponent)
+})
+export class StepperComponent extends CustomInput<any> implements AfterContentInit  {
+
+  constructor() { super(); }
+  ngAfterContentInit(): void {
+    if(this.lstSteps){
+      this.lstSteps.filter(p => !p.parent).forEach(comp => { comp.parent = this; });
+    }
+  }
+
+  override async ngOnInit() {
+    super.ngOnInit();
+  }
+
+  @ContentChildren(StepComponent) lstSteps : QueryList<StepComponent>;
+
+  override writeValue(value: any){ this.setModel(value) }
+  override get model(): any      { return this._model;  }
+  override set model(value: any) { this.setModel(value); this.propagateChange(this._model); }
+
+  override _model: number = 0;
+  setModel(value){
+    this._model = value;
+    this.ngAfterContentInit();
+  }
+}

package/src/lib/components/stepper/stepper.module.ts

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { StepComponent } from './step/step.component';
+import { StepperComponent } from './stepper.component';
+import { IonicModule } from '@ionic/angular';
+
+@NgModule({
+  declarations: [ StepComponent, StepperComponent ],
+  exports: [ StepComponent, StepperComponent ],
+  imports: [
+    CommonModule,
+    IonicModule
+  ]
+})
+export class StepperModule { }

package/src/lib/components/tabs/tab/tab.component.html

@@ -0,0 +1,8 @@
+<div [ngClass]="{'-translate-x-full opacity-0': !active,
+                 '!relative': relative }" class="default-transition overflow-hidden max-h-full size-full absolute top-0 left-0">
+  @if(route && active){
+    <router-outlet class="size-full"></router-outlet>
+  }@else {
+    <ng-content></ng-content>
+  }
+</div>

package/src/lib/components/tabs/tab/tab.component.ts

@@ -0,0 +1,28 @@
+import { Component, Input, ViewChild, ViewContainerRef } from "@angular/core";
+import { RouterOutlet } from "@angular/router";
+import { Utils } from "../../../services/utils.service";
+
+@Component({
+  selector: 'tab',
+  templateUrl: './tab.component.html',
+  styleUrls: ['./tab.component.scss'],
+})
+export class TabComponent {
+  @Input() id   : string  = null;
+
+  @Input() label: string  = "Label";
+  /** Icone da aba @link https://ionic.io/ionicons */
+  @Input() name : string  = "warning";
+  /** Rota aba, quando náo informada irá mostrar o conteudo do componente */
+  @Input() public route : string | null = null;
+  @Input() active: boolean = false;
+  @Input() relative: boolean = false;
+
+  constructor() { }
+
+  @ViewChild('placeToRender', {read: ViewContainerRef}) placeToRender: ViewContainerRef;
+  routerOutlet: RouterOutlet | null = null;
+
+  guid = Utils.GenerateGUID();
+}
+

package/src/lib/components/tabs/tabs/tabs.component.html

@@ -0,0 +1,14 @@
+<div class="flex flex-col size-full">
+  <div class="h-10 w-full flex px-3 mask-x/3 overflow-x-auto">
+    @for (tab of lstTabs; track $index) {
+      <div [routerLink]="tab.route ? '.' + tab.route : GetElse()" [ngClass]="{'selected': tab.active}" class="default-transition !translucid-background translucid-border tab-selector !border-b-0 animated-from-right whitespace-nowrap" (click)="SetActiveTab(tab)">
+        <ion-text class="mx-auto" [color]="tab.active ? 'dark' : ''">
+          <ion-icon [name]="tab.name" class="align-sub mr-1"></ion-icon> {{tab.label}}
+        </ion-text>
+      </div>
+    }
+  </div>
+  <div class="translucid-border tab-content !overflow-hidden relative">
+    <ng-content></ng-content>
+  </div>
+</div>

package/src/lib/components/tabs/tabs/tabs.component.ts

@@ -0,0 +1,42 @@
+import { AfterContentInit, Component, ContentChild, ContentChildren, EventEmitter, OnInit, Output, QueryList } from '@angular/core';
+import { TabComponent } from '../tab/tab.component';
+import { RouterOutlet } from '@angular/router';
+
+@Component({
+  selector: 'tabs',
+  templateUrl: './tabs.component.html',
+  styleUrls: ['./tabs.component.scss'],
+})
+export class TabsComponent implements AfterContentInit {
+
+  @ContentChildren(TabComponent) lstTabs: QueryList<TabComponent>;
+  @ContentChild(RouterOutlet)  router: RouterOutlet;
+  
+  /** Emitido quando a aba é trocada. Emite o ID do elemento */
+  @Output('change') changeEmitter: EventEmitter<string> = new EventEmitter<string>();
+
+  constructor(
+  ) { }
+
+  ngAfterContentInit(): void {
+    let activeTabs = this.lstTabs.filter((tab) => tab.active);
+    if(activeTabs.length == 0 && this.lstTabs.length > 0) { this.SetActiveTab(this.lstTabs.first); }
+  
+    let currentLocationTabs = this.lstTabs.filter(tab => tab.route).filter((tab) => window.location.pathname.toLocaleLowerCase().includes((tab.route).toLocaleLowerCase()));
+    if(currentLocationTabs.length > 0){ this.SetActiveTab(currentLocationTabs[0]); }
+  }
+
+  ActiveTab: TabComponent | null = null;
+  SetActiveTab(tab: TabComponent){
+    this.lstTabs.forEach(tab => tab.active = false);
+    tab.active = true;
+    this.ActiveTab = tab;
+    if(tab.route){ this.isComponent = false; } else{ this.isComponent = true; }
+    this.changeEmitter.emit(this.ActiveTab.id);
+  }
+  isComponent: boolean = true;
+
+  GetElse(){
+    return this.lstTabs.some(p => p.route != null) ? './' : undefined
+  }
+}

package/src/lib/components/tabs/tabs.module.ts

@@ -0,0 +1,15 @@
+import { RouterLinkWithHref, RouterModule } from '@angular/router';
+import { CommonModule } from '@angular/common';
+import { IonicModule } from '@ionic/angular';
+import { NgModule } from '@angular/core';
+
+import { TabsComponent } from './tabs/tabs.component';
+import { TabComponent } from './tab/tab.component';
+import { NgVarDirective } from '../../directives/ng-var.directive';
+
+@NgModule({
+  declarations: [ TabsComponent, TabComponent ],
+  exports     : [ TabsComponent, TabComponent ],
+  imports: [ CommonModule, IonicModule, NgVarDirective, RouterLinkWithHref, RouterModule ]
+})
+export class TabsModule { }

package/src/lib/components/text-tooltip/text-tooltip.component.html

@@ -0,0 +1,8 @@
+<div #text class="w-full truncate relative  overflow-hidden">
+  <ng-content select="[slot=content]"></ng-content>
+</div>
+<div class="absolute top-0 left-0 size-full">
+  <tooltip [color]="color" [align]="align" *ngIf="isOverflowing" [hidden]="!isOverflowing">
+    <ng-content select="[slot=tooltip]"></ng-content>
+  </tooltip>
+</div>

package/src/lib/components/text-tooltip/text-tooltip.component.ts

@@ -0,0 +1,45 @@
+import { AfterContentInit, Component, ElementRef, HostListener, Input, OnChanges, SimpleChanges, ViewChild } from '@angular/core';
+import { TooltipComponent } from '../tooltip/tooltip.component';
+import { IonicModule } from '@ionic/angular';
+import { CommonModule } from '@angular/common';
+
+@Component({
+  selector: 'text-tooltip',
+  standalone: true,
+  imports: [CommonModule, IonicModule, TooltipComponent],
+  templateUrl: './text-tooltip.component.html',
+  styleUrls: ['./text-tooltip.component.scss'],
+})
+export class TextTooltipComponent implements OnChanges, AfterContentInit  {
+  isOverflowing: boolean = true;
+
+  @ViewChild('text') text: ElementRef<HTMLDivElement>;
+  private CheckOverflowHandler(){
+    if(this.text){ this.isOverflowing = this.text.nativeElement.scrollWidth > this.text.nativeElement.clientWidth; }
+  };
+  
+  @Input() align: 'top' | 'bottom' | 'left' | 'right' = 'right';
+  @Input() color: string= 'secondary';
+
+  constructor() { 
+  }
+  
+  @HostListener("mouseenter")
+  onMouseEnter() {
+    this.CheckOverflowHandler()
+  }
+
+  ngOnChanges(changes: SimpleChanges) {
+    setTimeout(() => this.CheckOverflowHandler(), 100)
+  }
+
+  ngAfterContentInit(): void {
+    this.CheckOverflowHandler();
+  }
+
+  @HostListener("window:resize")
+  onResize() {
+    this.CheckOverflowHandler()
+  }
+
+}

package/src/lib/components/tooltip/tooltip.component.html

@@ -0,0 +1,53 @@
+<!-- <div
+  class="
+    absolute
+    
+
+    default-transition px-2
+    min-w-fit h-fit py-1
+    bg-[var(--ion-color-secondary)] 
+    rounded-xl
+  "
+  [ngClass]="{'!translate-x-0 !translate-y-0 !opacity-100': _active}"
+> 
+  <div class="absolute -left-1 top-0 rounded bottom-0 my-auto rotate-45 h-4 aspect-square bg-red-500 [clip-path:polygon(0_20%,_0%_100%,_80%_100%)]"></div>
+  <div class="z-[100] whitespace-nowrap">
+    <ng-content></ng-content>
+  </div>
+</div>  -->
+<div #wrapper id="wrapper" class="size-full absolute left-0 right-0 animated">
+  <div
+    id="tooltip"
+    style="--background: var(--ion-color-{{color}})"
+    class="
+      !pointer-events-none
+      absolute
+      default-transition px-2
+      min-w-fit h-fit py-1
+      bg-[var(--background)]
+      rounded-xl blur-sm
+      opacity-0
+      max-w-full
+      {{align}}
+    "
+  > 
+    @switch (align) {
+      @case ('top') {
+        <div class="absolute rounded -bottom-1 left-0 right-0 mx-auto -rotate-45 h-4 aspect-square bg-[var(--background)] [clip-path:polygon(0_20%,_0%_100%,_80%_100%)]"></div>
+      }
+      @case ('bottom') {
+        <div class="absolute rounded -top-1 left-0 right-0 mx-auto rotate-[135deg] h-4 aspect-square bg-[var(--background)] [clip-path:polygon(0_20%,_0%_100%,_80%_100%)]"></div>
+      }
+      @case ('right') {
+        <div class="absolute rounded -left-1 top-0 bottom-0 my-auto rotate-45 h-4 aspect-square bg-[var(--background)] [clip-path:polygon(0_20%,_0%_100%,_80%_100%)]"></div>
+      }
+      @case ('left') {
+        <div class="absolute rounded -right-1 top-0 bottom-0 my-auto -rotate-[135deg] h-4 aspect-square bg-[var(--background)] [clip-path:polygon(0_20%,_0%_100%,_80%_100%)]"></div>
+      }
+    }
+    <div class="z-[100] block text-dark text-sm">
+      <ng-content></ng-content>
+    </div>
+  </div> 
+</div>
+

package/src/lib/components/tooltip/tooltip.component.ts

@@ -0,0 +1,16 @@
+import { CommonModule } from '@angular/common';
+import { AfterViewInit, Component, ElementRef, Host, Input, input, OnDestroy, OnInit, SkipSelf, ViewChild } from '@angular/core';
+import { IonicModule } from '@ionic/angular';
+
+@Component({
+  selector: 'tooltip',
+  standalone: true,
+  imports: [CommonModule, IonicModule],
+  templateUrl: './tooltip.component.html',
+  styleUrls: ['./tooltip.component.scss'],
+})
+export class TooltipComponent {
+
+  @Input() align: 'top' | 'bottom' | 'left' | 'right' = 'right';
+  @Input() color: string= 'secondary';
+}

package/src/lib/core.module.ts

@@ -0,0 +1,26 @@
+import { InjectionToken, ModuleWithProviders, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+import { Environment } from './classes/environment';
+import { EnvironmentService } from './services/environment.service';
+
+export const EnvironmentInjectionToken = new InjectionToken<Environment>('Environment');
+
+
+@NgModule({
+  declarations: [],
+  exports     : [],
+  imports: [
+    CommonModule
+  ],
+})
+export class SapphireIonFrameworkModule { 
+  static forRoot(config: Environment): ModuleWithProviders<SapphireIonFrameworkModule> {
+    return { 
+      ngModule: SapphireIonFrameworkModule,
+      providers: [ 
+        EnvironmentService, { provide: EnvironmentInjectionToken, useValue: config }, 
+      ]
+    }
+  }
+}

package/src/lib/directives/ng-var.directive.ts

@@ -0,0 +1,26 @@
+import { Directive, Input, TemplateRef, ViewContainerRef } from "@angular/core";
+
+@Directive({
+  standalone: true,
+  selector: '[ngVar]',
+})
+export class NgVarDirective {
+  @Input()
+  set ngVar(context: unknown) {
+      this.context.$implicit = this.context.ngVar = context;
+
+      if (!this.hasView) {
+        this.vcRef.createEmbeddedView(this.templateRef, this.context);
+        this.hasView = true;
+      }
+  }
+
+  private context: { $implicit: unknown; ngVar: unknown; } = { $implicit: null, ngVar: null, };
+
+  private hasView: boolean = false;
+
+  constructor(
+    private templateRef: TemplateRef<any>,
+    private vcRef: ViewContainerRef
+  ) {}
+}

package/src/lib/guards/auth.guard.ts

@@ -0,0 +1,19 @@
+import { CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, Router } from '@angular/router';
+import { Injectable } from '@angular/core';
+
+import { AuthService } from '../services/auth.service';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+
+  constructor(private auth: AuthService, private router: Router) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean> {
+    const Token = await this.auth.LoadToken();
+    const Authenticated = this.auth.isTokenValid(Token);
+    if(!Authenticated){
+      this.auth.Loggout();
+    }
+    return Authenticated;
+  }
+}

package/src/lib/guards/error.interceptor.ts

@@ -0,0 +1,107 @@
+import { HttpClient, HttpErrorResponse, HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Observable, catchError } from "rxjs";
+import { ToastController } from "@ionic/angular";
+import { Injectable } from "@angular/core";
+
+import { ApiUrlProviderService } from "../services/web/api-url-provider.service";
+import { GenericService } from "../services/generics.service";
+import { AuthService } from "../services/auth.service";
+import { Router } from "@angular/router";
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ErrorInterceptor implements HttpInterceptor {
+
+  constructor(
+    private auth: AuthService,
+    private http: HttpClient,
+    private genericService: GenericService,
+    private toastController: ToastController,
+    private apiUrlProviderService: ApiUrlProviderService,
+    private router: Router
+  ) {}
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    return next.handle(req).pipe(
+      catchError((error: HttpErrorResponse) => { 
+        // if(error.status == 0){
+        //   this.PresentErrorToast(error.error, req, error);
+        // }
+        if(error.status == 401){ 
+          this.auth.Loggout(); 
+        }else 
+        if(error.status == 403){
+          this.router.navigate(['/403'])
+        } else
+        if(error.status != 404){ 
+          this.PresentErrorToast(error.error, req, error);
+        }
+        throw error;
+      })
+    );
+  }
+
+  private localUserKey: string = "APLICATION_USER_KEY";
+  private localAdminKey: string = "APLICATION_ADMIN_KEY";
+  async PresentErrorToast(json: string, request: any, fullError: any) {
+    var res: ApiErrorReturn = null;
+    try{
+      res = JSON.parse(json) as ApiErrorReturn
+    }catch{
+      res = { Erro: "Não foi possivel converter o JSON de retorno!", Mensagem: "Ocorreu um erro inesperado!", _Info: "" }
+    }
+    res._Info = await this.GetInfo(request, fullError);
+
+    const toast = await this.toastController.create({
+      message: res.Mensagem,
+      duration: 5000,
+      icon: "bug",
+      position: 'bottom',
+      translucent: false, 
+      cssClass: 'ionic-toast',
+      buttons: [
+        { 
+          text: "Reportar Erro",
+          icon: "document",
+          side: "end",
+          handler: () => {
+            this.Report(res);
+          }
+        }
+      ]
+    });
+
+    await toast.present();
+  }
+
+  protected get fullRoute(): string{
+    return this.apiUrlProviderService.apiUrl + 'error'
+  }
+  Report(res: ApiErrorReturn): void{
+    this.http.post(this.fullRoute, res).subscribe({
+      next: (res) => { this.genericService.PresentToast("Erro informado com sucesso!", "checkmark-circle"); },
+      error:(err) => { this.genericService.PresentToast("Ocorreu um erro inesperado no retorno do erro!"); }
+    });
+  }
+
+  async GetInfo(request: any, fullError: any): Promise<string>{
+    return JSON.stringify({
+      token     : this.auth.LoadToken(),
+      tokenAdmin: this.auth.LoadTokenAdmin(),
+      currentUrl: window.location.href,
+      userId    : (await this.auth.LoadToken()).id,
+      jwtAdmin  : localStorage.getItem(this.localAdminKey),
+      jwtUser   : localStorage.getItem(this.localUserKey),
+      request   : request,
+      error     : fullError,
+      apiUrl    : this.apiUrlProviderService.apiUrl
+    });
+  }
+}
+
+class ApiErrorReturn {
+  Mensagem: string;
+  Erro: string;
+  _Info: string;
+}

package/src/lib/guards/token.interceptor.ts

@@ -0,0 +1,28 @@
+import { AuthService } from '../services/auth.service';
+import { Injectable } from '@angular/core';
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor
+} from '@angular/common/http';
+import { Observable, first, firstValueFrom, from, lastValueFrom, mergeMap, switchMap } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TokenInterceptor implements HttpInterceptor {
+
+  constructor(
+    private auth: AuthService
+  ) {}
+
+  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {
+    return from(this.auth.JWToken()).pipe( 
+      switchMap((authToken: string) => {
+        const authReq = request.clone({ setHeaders: { Authorization: `Bearer ${authToken}` } });
+        return next.handle(authReq);
+      })
+    );
+  }
+}