@dev-tcloud/tcloud-ui 2.2.2 → 2.2.3

package/projects/tcloud-ui/src/lib/_directives/directives.module.ts

@@ -0,0 +1,24 @@
+import { NgModule } from '@angular/core';
+import { TCloudUiAlignDirective } from './align/align.directive';
+import { TCloudUiHoverParentDirective } from './hover-parent/hover-parent.directive';
+import { TCloudUiTooltipDirective } from './tooltip/tooltip.directive';
+import { TCloudUiElCopyDirective } from './el-copy/el-copy.directive';
+import { TCloudCurrencyDirective } from './currency/currency.directive';
+
+@NgModule({
+  declarations: [
+    TCloudUiTooltipDirective,
+    TCloudUiAlignDirective,
+    TCloudUiHoverParentDirective,
+    TCloudUiElCopyDirective,
+    TCloudCurrencyDirective
+  ],
+  exports: [
+    TCloudUiTooltipDirective,
+    TCloudUiAlignDirective,
+    TCloudUiHoverParentDirective,
+    TCloudUiElCopyDirective,
+    TCloudCurrencyDirective
+  ],
+})
+export class TCloudUiDirectiveModule {}

package/projects/tcloud-ui/src/lib/_directives/el-copy/el-copy.directive.ts

@@ -0,0 +1,78 @@
+import { Directive, ElementRef, OnInit, Renderer2, Input} from '@angular/core';
+
+
+@Directive({
+  selector: '[TCCopy]'
+})
+export class TCloudUiElCopyDirective implements OnInit{
+
+  private _isCopy: boolean = false;
+  
+  constructor(
+    private el: ElementRef,
+    private renderer: Renderer2
+    ) {}
+
+  ngOnInit(): void {
+    this.setItemFuncCopy();
+  }
+
+  setItemFuncCopy(){
+
+    const btn_copy = this.renderer.createElement('i');
+
+    var copyText = ()=>{        
+        const elementWithCopyAttribute = document.querySelector(`[data-el-copy="${id}"]`) as any;
+        let copyText = ''
+        if( elementWithCopyAttribute && elementWithCopyAttribute.tagName && (elementWithCopyAttribute.tagName).toUpperCase() === 'INPUT' ){
+          copyText = elementWithCopyAttribute?.value!;
+        }else{
+          copyText = elementWithCopyAttribute?.textContent!;
+        }        
+        navigator.clipboard.writeText(copyText);
+        this.renderer.removeClass(btn_copy, 'fa-copy');
+        this.renderer.addClass(btn_copy, 'fa-check');
+        setTimeout(() => {
+            this.renderer.removeClass(btn_copy, 'fa-check');
+            this.renderer.addClass(btn_copy, 'fa-copy');
+        }, 3000);
+        
+    }
+
+    const id = this.generateID();
+    this.renderer.setAttribute(this.el.nativeElement, 'data-el-copy', `${id}`);
+
+    
+    this.renderer.setStyle(btn_copy, 'cursor', 'pointer');
+    this.renderer.setStyle(btn_copy, 'margin-left', '3px');
+    this.renderer.addClass(btn_copy, 'fas');
+    this.renderer.addClass(btn_copy, 'fa-copy');
+
+    this.renderer.addClass(btn_copy, 'tcloud-ui-el-copy');
+    this.renderer.setAttribute(btn_copy, 'id', id);
+    this.renderer.setAttribute(btn_copy, 'title', 'Copy');
+    this.renderer.listen(btn_copy, 'click', () => { copyText(); });
+
+    if( ((this.el.nativeElement).tagName).toUpperCase() === 'INPUT' ){
+      let classList = this.el.nativeElement?.classList!
+      if( classList && (classList).length > 0 && ('tc-form-control').indexOf(classList) > -1 ){
+        this.renderer.addClass(btn_copy, 'tcloud-ui-el-input-copy-tc-form-control');
+      }else{
+        this.renderer.addClass(btn_copy, 'tcloud-ui-el-input-copy');
+      }      
+      this.renderer.appendChild(this.el.nativeElement.parentNode, btn_copy);
+    }else{
+      this.renderer.appendChild(this.el.nativeElement, btn_copy);
+    }
+
+    
+
+    
+  }
+
+  generateID(target?: string): string{
+    const ref = (target) ? `-${target}` : '';
+    return `tc-el-copy-${Math.floor(Math.random() * Math.floor(Math.random() * Date.now()))}${ref}`;
+  }
+
+}

package/projects/tcloud-ui/src/lib/_directives/hover-parent/hover-parent.directive.ts

@@ -0,0 +1,52 @@
+
+import { Directive, Input, Renderer2, HostListener } from '@angular/core';
+
+@Directive({
+  selector: '[TCHoverParent]'
+})
+export class TCloudUiHoverParentDirective {
+
+  private CLASS: string | undefined;
+  private ID: string | undefined;
+
+  constructor(
+    private renderer: Renderer2
+  ) {}
+
+  @HostListener('mouseover') onMouseOver() {
+    if( this.getElement() ){
+      const el = <any> this.getElement();
+      if( el ){
+        this.renderer.addClass(el, (this.CLASS) ? this.CLASS : 'tcloud-hover-parent');
+      }
+    } 
+  }
+
+  @HostListener('mouseout') onMouseOut() {
+    if( this.getElement() ){
+      const el = <any> this.getElement();
+      if( el ){
+        this.renderer.removeClass(el, (this.CLASS) ? this.CLASS : 'tcloud-hover-parent');
+      }
+     
+    }    
+  }
+
+  @Input() set TCHoverParent (id: string){
+    if (id){ this.ID = id; }
+  }
+
+  @Input() set TCHoverParentClass (clss: any){
+    if (clss){
+      this.CLASS = clss;
+    }
+  }
+
+  getElement(): HTMLElement | undefined{
+    if( this.ID ){
+        return document.getElementById(this.ID) || undefined;
+    }
+    return undefined;
+  }
+
+}

package/projects/tcloud-ui/src/lib/_directives/tooltip/tooltip.directive.ts

@@ -0,0 +1,159 @@
+import { Directive, ElementRef, Renderer2, Input, HostListener} from '@angular/core';
+
+
+@Directive({
+  selector: '[TCtooltip]'
+})
+export class TCloudUiTooltipDirective {
+
+  remove: boolean = false;
+
+  info_text: string = '';
+
+  @HostListener('mouseover', ['$event']) onMouseOver(event: MouseEvent) {
+
+    let hoverInCallback = () => {
+      this.remove = false;
+    }
+
+    let hoverOutCallback = () => {
+      this.remove = true;
+      const customDiv = <any> document.querySelector('.tc-directive-tooltip');
+      if( customDiv ){ customDiv.remove(); }      
+    }
+
+    hoverOutCallback;
+
+    setTimeout(() => {
+      const scrollTop = window.scrollY || window.pageYOffset;
+      const tooltip = this.renderer.createElement('div');
+      const rect  = this.el.nativeElement?.getBoundingClientRect();
+      // const direction = this.el.nativeElement?.attributes['ng-reflect--t-cdirection']?.value || 'top';
+      const direction = this._direction || 'top';
+      const el_position_x = (rect?.left) ? parseInt(rect?.left) : 0;
+      const el_position_y = (rect?.top ) ? parseInt(rect?.top  + scrollTop) : 0;
+
+      let width = 0;
+      let height = 0;
+      if( event && event.target ){
+        const _event = event.target as any;
+        height  = _event.offsetHeight;
+        width   = _event.offsetWidth;
+      }
+
+      const top = `${(el_position_y - ((height/2) + 10) )}px`;
+      const left = `${el_position_x + (width/2) }px`;
+      this.renderer.setStyle(tooltip, 'top', '0px');
+      this.renderer.setStyle(tooltip, 'left', '0px');
+      this.renderer.setStyle(tooltip, 'opacity', '0');
+      this.renderer.addClass(tooltip, 'tc-directive-tooltip');
+      this.renderer.addClass(tooltip, `tc-directive-tooltip-${direction}`);
+      const id = this.generateID();
+      this.renderer.setAttribute(tooltip, 'id', id);
+      const textNode = this.info_text;
+
+      if( textNode !== undefined && textNode !== null && textNode !== '' ){
+
+        tooltip.innerHTML = textNode;
+        this.renderer.appendChild(document.body, tooltip);    
+        this.start_tooltip(id, height, width, el_position_x, el_position_y, direction);
+
+        if (tooltip) {
+          tooltip.addEventListener('mouseenter', hoverInCallback);
+          tooltip.addEventListener('mouseleave', hoverOutCallback);
+        }
+      }
+
+    });
+
+  }  
+
+  @HostListener('mouseout', ['$event']) onMouseOut(event: MouseEvent) {   
+    this.remove = true;
+    this.remove_tooltip( document.querySelector('.tc-directive-tooltip') );
+  }
+
+  remove_tooltip(customDiv: any){   
+    if (customDiv) {      
+      setTimeout(() => {
+        if( this.remove ){
+          customDiv.remove();
+        }
+      }, 30);      
+    }
+  }
+
+
+  @Input() set TCtooltip (tooltip: any){
+    if (tooltip){
+      if( typeof tooltip === 'object' ){
+      }else{
+        this.info_text = tooltip;
+      }      
+    }
+  }
+
+  private _direction: 'top' | 'bottom' | 'left' | 'right' = 'top';
+  @Input() set TCdirection (direction: any){
+    if (direction){
+      this._direction = direction;
+    }
+  }
+  
+  constructor(
+    private el: ElementRef,
+    private renderer: Renderer2
+  ) {}
+
+
+  generateID(target?: string): string{
+    const ref = (target) ? `-${target}` : '';
+    return `tc-tooltip-${Math.floor(Math.random() * Math.floor(Math.random() * Date.now()))}${ref}`;
+  }
+
+  start_tooltip(id: string, height: number, width: number, el_position_x: number, el_position_y: number, direction: string){
+    setTimeout(() => {      
+      const tooltip: any = document.getElementById(id);
+      const tooltip_height = tooltip.clientHeight;
+      const tooltip_width = tooltip.clientWidth;
+
+      /*
+      console.log('altura do target: ', height);
+      console.log('largura do target: ', width);
+      console.log('el_position_x do target: ', el_position_x);
+      console.log('el_position_y do target: ', el_position_y);
+      console.log('direction do tooltip: ', direction);
+      */
+
+      let p_y = 0;
+      let p_x = 0;
+      const center_position = (el_position_x + (width/2)) - (tooltip_width/2);
+
+      if( direction === 'top' ){
+        p_y = (el_position_y - tooltip_height) - 15;
+        p_x = center_position;
+      }
+
+      if( direction === 'bottom' ){
+        p_y = (el_position_y + height) + 15;
+        p_x = center_position;
+      }
+
+      if( direction === 'left' ){
+        p_y = el_position_y - (tooltip_height/2) + (height/2);
+        p_x = center_position - tooltip_width/2 - width/2 - 15;
+      }
+
+      if( direction === 'right' ){
+        p_y = el_position_y - (tooltip_height/2) + (height/2);
+        p_x = center_position + tooltip_width/2 + width/2 + 15;
+      }
+
+      this.renderer.setStyle(tooltip, 'top', `${p_y}px`);
+      this.renderer.setStyle(tooltip, 'left', `${p_x}px`);
+      this.renderer.addClass(tooltip, 'tc-tooltip-fade-in');
+
+    });
+  }
+
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/components/tcloud-ui-accordion-body/tcloud-ui-accordion-body.component.html

@@ -0,0 +1,3 @@
+<div class="tcloud-ui-accordion-body tc-accordion-content"  [class.show]="show" [@expandAccordion]="(show) ? 'open' : 'close' ">
+    <ng-content></ng-content>
+</div>

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/components/tcloud-ui-accordion-body/tcloud-ui-accordion-body.component.scss

@@ -0,0 +1,9 @@
+.show{
+    display: block !important;
+    padding-top: 15px;
+    padding-bottom: 15px;
+}
+
+.tc-accordion-content{
+    overflow: hidden;
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/components/tcloud-ui-accordion-body/tcloud-ui-accordion-body.component.ts

@@ -0,0 +1,34 @@
+import { Component, OnInit } from '@angular/core';
+import { TCloudUiAccordionService } from '../../services/tcloud-ui-accordion.service';
+import { trigger, state, style, animate, transition } from '@angular/animations';
+
+@Component({
+  selector: 'tcloud-ui-accordion-body',
+  templateUrl: './tcloud-ui-accordion-body.component.html',
+  styleUrls: ['./tcloud-ui-accordion-body.component.scss'],
+  animations: [
+    trigger('expandAccordion', [
+      state('close', style({ height: '0' })),
+      state('open', style({ height: '*' })),
+      transition('close <=> open', animate('0.35s ease-in-out')),
+    ]),
+  ],
+})
+export class TCloudUiAccordionBodyComponent implements OnInit {
+
+  show: boolean = false;
+  
+  constructor(
+    private _tCloudUiAccordionService: TCloudUiAccordionService
+  ) { }
+
+  ngOnInit(): void {
+
+    this.show = this._tCloudUiAccordionService.getShow() || false;
+    this._tCloudUiAccordionService.stateToggle$.subscribe((show: boolean) => {
+      this.show = show;
+    })
+
+  }
+
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/components/tcloud-ui-accordion-title/tcloud-ui-accordion-title.component.css

@@ -0,0 +1,31 @@
+.tc-accordion-table{
+    width: 100%;
+}
+
+.tc-accordion-actions{
+    width: 15px;
+}
+
+.tc-btn-accordion-toggle{
+    font-size: 20px;
+    border: none;
+    background-color: transparent;
+    background: none;
+    cursor: pointer;
+    margin: auto;
+}
+
+.tc-btn-accordion-toggle:disabled{
+    cursor: not-allowed !important;
+    opacity: 0.6;
+}
+
+.icon-toggle{
+    color: var(--tc-primary);
+}
+
+.area-title{
+    width: 100; 
+    cursor: pointer;
+    color: var(--tc-primary);
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/components/tcloud-ui-accordion-title/tcloud-ui-accordion-title.component.html

@@ -0,0 +1,17 @@
+<div class="tcloud-ui-accordion-title tc-accordion-title">
+    <table class="tc-accordion-table">
+        <tr>
+            <td class="area-title" (click)="toggle_title()" >
+                <ng-content></ng-content>
+            </td>
+            <td class="tc-accordion-actions">
+                <button type="button" class="tc-btn-accordion-toggle" [disabled]="disabled" (click)="toggle()" >
+
+                    <i class="fas fa-chevron-right icon-toggle" *ngIf="!show"></i>
+                    <i class="fas fa-chevron-down icon-toggle" *ngIf="show"></i>
+
+                </button>
+            </td>
+        </tr>
+    </table>
+</div>

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/components/tcloud-ui-accordion-title/tcloud-ui-accordion-title.component.ts

@@ -0,0 +1,62 @@
+import { Component, OnInit, Output, EventEmitter, OnDestroy } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { TCloudUiAccordionService } from '../../services/tcloud-ui-accordion.service';
+
+@Component({
+  selector: 'tcloud-ui-accordion-title',
+  templateUrl: './tcloud-ui-accordion-title.component.html',
+  styleUrls: ['./tcloud-ui-accordion-title.component.css']
+})
+export class TCloudUiAccordionTitleComponent implements OnInit, OnDestroy {
+
+  subscription_01: Subscription | undefined;
+  subscription_02: Subscription | undefined;
+  subscription_03: Subscription | undefined;
+
+  show: boolean = false;
+  loading: boolean = false;
+  disabled: boolean = false;
+ 
+
+  constructor(
+    private _tCloudUiAccordionService: TCloudUiAccordionService
+  ) { }
+
+  ngOnInit(): void {
+
+    this.loading = this._tCloudUiAccordionService.getLoading() || false;
+    this.subscription_01 = this._tCloudUiAccordionService.stateLoading$.subscribe((loading: boolean) => {
+      this.loading = loading;
+    });
+
+    this.show = this._tCloudUiAccordionService.getShow() || false;
+    this.subscription_02 = this._tCloudUiAccordionService.stateToggle$.subscribe((show: boolean) => {
+      this.show = show;
+    });
+
+    this.disabled = this._tCloudUiAccordionService.getDisabled() || false;
+    this.subscription_03 = this._tCloudUiAccordionService.stateDisabled$.subscribe((disabled: boolean) => {
+      this.disabled = disabled;
+    });
+
+  }
+
+  toggle(){
+    if( this.disabled ){ return; }
+
+    this.show = !this.show;
+    this._tCloudUiAccordionService.toggle(this.show);  
+    
+  }
+
+  toggle_title(){
+    this.toggle();
+  }
+
+  ngOnDestroy(): void {
+    if( this.subscription_01 ){ this.subscription_01.unsubscribe(); }
+    if( this.subscription_02 ){ this.subscription_02.unsubscribe(); }
+    if( this.subscription_03 ){ this.subscription_03.unsubscribe(); }
+  }
+
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/services/tcloud-ui-accordion.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+
+@Injectable()
+export class TCloudUiAccordionService {
+
+  private disabled: boolean | undefined;
+  private loading: boolean | undefined;
+  private show: boolean | undefined;
+
+  private _stateToggle = new Subject<boolean>();
+  public stateToggle$ = this._stateToggle.asObservable();
+
+  private _stateLoading = new Subject<boolean>();
+  public stateLoading$ = this._stateLoading.asObservable();
+
+  private _stateDisabled = new Subject<boolean>();
+  public stateDisabled$ = this._stateDisabled.asObservable();
+
+
+  toggle(action: boolean): void{
+    this._stateToggle.next( action );
+  }
+
+  getLoading(){
+    return this.loading;
+  }
+
+  setLoading(loading: boolean){
+    this.loading = loading;
+    this._stateLoading.next(loading);
+  }
+
+  getShow(){
+    return this.show;
+  }
+
+  setDisabled(disabled: boolean): void{
+    this._stateDisabled.next( disabled );
+  }
+
+  getDisabled(){
+    return this.disabled;
+  }
+
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/tcloud-ui-accordion.component.css

@@ -0,0 +1,11 @@
+.tc-accordion{
+    border: 1px solid #ccc;
+    padding: 8px 12px;
+    border-radius: 15px;
+    margin-bottom: 5px;
+}
+
+.tc-accordion-disabled{
+    background-color: #e3e3e3;
+    opacity: 0.6;
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/tcloud-ui-accordion.component.html

@@ -0,0 +1,3 @@
+<div class="tcloud-ui-accordion tc-accordion" [class.tc-accordion-disabled]="disabled">
+    <ng-content></ng-content>
+</div>

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/tcloud-ui-accordion.component.ts

@@ -0,0 +1,77 @@
+import { Subscription } from 'rxjs';
+import { Component, EventEmitter, Input, OnInit, Output, OnDestroy } from '@angular/core';
+import { TCloudUiAccordionService } from './services/tcloud-ui-accordion.service';
+
+@Component({
+  selector: 'tcloud-ui-accordion',
+  templateUrl: './tcloud-ui-accordion.component.html',
+  styleUrls: ['./tcloud-ui-accordion.component.css'],
+  providers: [
+    TCloudUiAccordionService
+  ],
+})
+export class TCloudUiAccordionComponent implements OnInit, OnDestroy {
+
+  subscription_01: Subscription | undefined;
+  subscription_02: Subscription | undefined;
+  
+  private _disabled: boolean = false;
+  @Input() set disabled(v: boolean){  
+    this._disabled = v;
+    if( this._disabled ){      
+      setTimeout(() => { 
+        this._tCloudUiAccordionService.setDisabled(this._disabled);
+        this._tCloudUiAccordionService.toggle(false); 
+      });
+    }
+  }
+  get disabled(){ return this._disabled; }
+
+
+  private _show: boolean = false;
+  @Input() set show(v: boolean){    
+    if( this._show !== v ){
+      this._show = v;
+      if( !this.disabled ){
+        setTimeout(() => { this._tCloudUiAccordionService.toggle(this._show); }); 
+      }           
+    }
+  }
+
+  get show(){ return this._show; }
+
+
+  @Output() onAction = new EventEmitter<'open'|'close'>();
+
+  private _loading: boolean = false;
+  /**
+   * loading - boolean - Coloca o modal em modo de carregamento - default false
+   */
+  @Input() set loading(loading: boolean){ 
+    this._loading = loading;
+    this._tCloudUiAccordionService.setLoading(loading);
+  }
+  get loading(): boolean { return this._loading; }
+
+  constructor(
+    private _tCloudUiAccordionService: TCloudUiAccordionService
+  ) { }
+
+  ngOnInit(): void {
+
+    this.subscription_01 = this._tCloudUiAccordionService.stateLoading$.subscribe((loading: boolean) => {
+      this.loading = loading;      
+    });
+    
+    this.subscription_02 = this._tCloudUiAccordionService.stateToggle$.subscribe((show: boolean) => {
+      this.onAction.emit( (show === true) ? 'open' : 'close' );
+    })
+
+  }
+
+  ngOnDestroy(): void {
+    if( this.subscription_01 ){ this.subscription_01.unsubscribe(); }
+    if( this.subscription_02 ){ this.subscription_02.unsubscribe(); }
+  }
+
+}

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-accordion/tcloud-ui-accordion.module.ts

@@ -0,0 +1,25 @@
+import { CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TCloudUiAccordionComponent } from './tcloud-ui-accordion.component';
+import { TCloudUiAccordionTitleComponent } from './components/tcloud-ui-accordion-title/tcloud-ui-accordion-title.component';
+import { TCloudUiAccordionBodyComponent } from './components/tcloud-ui-accordion-body/tcloud-ui-accordion-body.component';
+
+
+
+@NgModule({
+  declarations: [
+    TCloudUiAccordionComponent,
+    TCloudUiAccordionTitleComponent,
+    TCloudUiAccordionBodyComponent
+  ],
+  exports: [
+    TCloudUiAccordionComponent,
+    TCloudUiAccordionTitleComponent,
+    TCloudUiAccordionBodyComponent
+  ],
+  imports: [
+    CommonModule
+  ],
+  schemas: [ CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA ]
+})
+export class TCloudUiAccordionModule { }

package/projects/tcloud-ui/src/lib/_modules/tcloud-ui-choice-issues/tcloud-ui-choice-issues.component.html

@@ -0,0 +1,42 @@
+<div class="tcloud-ui-choice-issues box p-2 mt-3 mb-2">
+  <input #campo [(ngModel)]="value" type="hidden" [value]="false" >
+  <div class="row">
+    <div class="col-md-8">
+      <p class="titulo">{{ titulo }}</p>      
+    </div>
+    <div class="col-md-4 text-right">  
+
+      <table class="mt-2 mr-2" *ngIf="!view" >
+        <tr>
+          <td>
+            <div class="form-fieldset">
+              <label [class.v-true]="value" class="mr-1"><input #campo name="{{ ID }}" [value]="true" type="radio" [(ngModel)]="value" (click)="setV(true)" >Sim</label>
+            </div>
+          </td>
+          <td>
+            <div class="form-fieldset">
+              <label [class.v-true]="!value" class="ml-2"><input #campo name="{{ ID }}" [value]="false" type="radio" [(ngModel)]="value" (click)="setV(false)" >Não</label>
+            </div>
+          </td>
+        </tr>
+      </table>    
+
+      <table class="mt-2 mr-2" *ngIf="view" >
+        <tr>
+          <td>
+            <div class="form-fieldset view" >
+              <label *ngIf="value" class="v-true disabled" >Sim</label>
+              <label *ngIf="!value">Não</label>
+            </div>
+          </td>
+        </tr>
+      </table>
+    </div>
+    <div class="col-md-12 mt-1">
+      <p class="sub-titulo">{{ subTitulo }}</p>
+    </div>
+    <div class="col-md-12 mt-2 mb-1">
+      <ng-content></ng-content>
+    </div>
+  </div>
+</div>