@seniorsistemas/components-ai 0.0.0-master-d4a804fe

package/esm2022/lib/directives/phone-mask.directive.mjs

@@ -0,0 +1,59 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PhoneMaskDirective {
+    el;
+    constructor(el) {
+        this.el = el;
+    }
+    onInput(event) {
+        const value = event.target.value;
+        this.applyPhoneMask(value);
+    }
+    onBlur(event) {
+        const value = event.target.value;
+        this.applyPhoneMask(value);
+    }
+    applyPhoneMask(value) {
+        if (!value)
+            return;
+        // Remove todos os caracteres não numéricos
+        const numbers = value.replace(/\D/g, '');
+        let maskedValue = '';
+        if (numbers.length <= 10) {
+            // Telefone fixo: (00) 0000-0000
+            maskedValue = numbers.replace(/(\d{2})(\d{4})(\d{4})/, '($1) $2-$3');
+        }
+        else if (numbers.length === 11) {
+            // Celular: (00) 00000-0000
+            maskedValue = numbers.replace(/(\d{2})(\d{5})(\d{4})/, '($1) $2-$3');
+        }
+        else {
+            // Limitar a 11 dígitos
+            const limitedNumbers = numbers.substring(0, 11);
+            maskedValue = limitedNumbers.replace(/(\d{2})(\d{5})(\d{4})/, '($1) $2-$3');
+        }
+        // Atualizar o valor do input apenas se mudou
+        if (maskedValue && maskedValue !== value) {
+            this.el.nativeElement.value = maskedValue;
+            // Disparar evento de input para atualizar o FormControl
+            const inputEvent = new Event('input', { bubbles: true });
+            this.el.nativeElement.dispatchEvent(inputEvent);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PhoneMaskDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: PhoneMaskDirective, isStandalone: true, selector: "[siaPhoneMask]", host: { listeners: { "input": "onInput($event)", "blur": "onBlur($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PhoneMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[siaPhoneMask]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/interceptors/api.interceptor.mjs

@@ -0,0 +1,55 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { catchError, throwError } from 'rxjs';
+import { AuthService } from '../services/auth.service';
+export const apiInterceptor = (req, next) => {
+    const authService = inject(AuthService);
+    const router = inject(Router);
+    // Get the access token, token type, and base URL
+    const accessToken = authService.getAccessToken();
+    const tokenType = authService.getTokenType();
+    const baseUrl = authService.getApiBaseUrl();
+    let modifiedReq = req;
+    // Add Authorization header if token exists
+    if (accessToken && tokenType) {
+        const authHeader = `${tokenType} ${accessToken}`;
+        modifiedReq = modifiedReq.clone({
+            setHeaders: {
+                Authorization: authHeader
+            }
+        });
+    }
+    // Prepend base URL if it exists and the request URL is relative
+    if (baseUrl && !isAbsoluteUrl(modifiedReq.url)) {
+        const fullUrl = combineUrls(baseUrl, modifiedReq.url);
+        modifiedReq = modifiedReq.clone({
+            url: fullUrl
+        });
+    }
+    return next(modifiedReq).pipe(catchError((error) => {
+        // Handle 401 Unauthorized errors
+        if (error.status === 401) {
+            // Redirect to forbidden route
+            router.navigate(['/forbidden']);
+        }
+        // Re-throw the error so other error handlers can process it
+        return throwError(() => error);
+    }));
+};
+/**
+ * Check if URL is absolute
+ */
+function isAbsoluteUrl(url) {
+    return /^https?:\/\//.test(url);
+}
+/**
+ * Combine base URL with relative URL
+ */
+function combineUrls(baseUrl, relativeUrl) {
+    // Remove trailing slash from base URL
+    const cleanBaseUrl = baseUrl.replace(/\/$/, '');
+    // Remove leading slash from relative URL
+    const cleanRelativeUrl = relativeUrl.replace(/^\//, '');
+    return `${cleanBaseUrl}/${cleanRelativeUrl}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/base-entity.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1lbnRpdHkuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy1haS9zcmMvbGliL21vZGVscy9iYXNlLWVudGl0eS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQmFzZUVudGl0eSB7XG4gIGNyZWF0ZWRCeT86IHN0cmluZztcbiAgY3JlYXRlZEF0PzogRGF0ZTtcbiAgY2hhbmdlZEJ5Pzogc3RyaW5nO1xuICBjaGFuZ2VkQXQ/OiBEYXRlO1xuICBjdXN0b20/OiBhbnk7XG59XG4iXX0=

package/esm2022/lib/models/entity-list.config.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-list.config.js","sourceRoot":"","sources":["../../../../projects/components-ai/src/lib/models/entity-list.config.ts"],"names":[],"mappings":"","sourcesContent":["import { TemplateRef } from '@angular/core';\nimport { ValidatorFn } from '@angular/forms';\n\n/**\n * Column configuration for entity list table\n */\nexport interface ColumnConfig {\n  field: string;\n  header: string;\n  sortable?: boolean;\n  width?: string;\n  type?: 'text' | 'number' | 'status' | 'custom';\n  customTemplate?: TemplateRef<any>;\n}\n\n/**\n * Lookup column configuration\n */\nexport interface LookupColumn {\n  field: string;\n  header: string;\n  width?: string;\n  type?: 'text' | 'number'; // Type of the field for filtering\n}\n\n/**\n * Responsive size configuration for filter fields\n */\nexport interface FilterFieldSize {\n  xs?: number; // Extra small screens (<576px)\n  sm?: number; // Small screens (≥576px)\n  md?: number; // Medium screens (≥768px)\n  lg?: number; // Large screens (≥992px)\n  xl?: number; // Extra large screens (≥1200px)\n}\n\n/**\n * Filter section configuration for grouping filters\n */\nexport interface FilterSection {\n  title: string;\n  filters: FilterConfig[];\n}\n\n/**\n * Filter configuration for entity list\n */\nexport interface FilterConfig {\n  field: string;\n  label: string;\n  type: 'text' | 'number' | 'dropdown' | 'lookup' | 'date';\n  options?: any[];\n  placeholder?: string;\n  optionLabel?: string;\n  optionValue?: string;\n  defaultValue?: any; // Default value for filter field\n  disabled?: boolean; // Static disabled state\n  min?: number; // For number inputs\n  max?: number; // For number inputs\n  disabledWhen?: { // Conditional disabled state\n    field: string;\n    value: any;\n  };\n  // Layout properties\n  colspan?: number; // Number of columns to span (1-12, default: 6)\n  size?: FilterFieldSize; // Responsive sizes object\n  colspanXs?: number; // Deprecated: use size.xs\n  colspanSm?: number; // Deprecated: use size.sm\n  colspanMd?: number; // Deprecated: use size.md\n  colspanLg?: number; // Deprecated: use size.lg\n  colspanXl?: number; // Deprecated: use size.xl\n  // Lookup specific properties\n  lookupService?: any; // Service to fetch lookup data\n  lookupDisplayField?: string; // Field to display in the lookup (default: 'name')\n  lookupDisplayFields?: string[]; // Multiple fields to display separated by ' - ' (overrides lookupDisplayField)\n  lookupValueField?: string; // Field to use as value (default: 'id')\n  lookupSearchFields?: string[]; // Fields to search in (default: ['name'])\n  lookupColumns?: LookupColumn[]; // Columns to display in lookup table\n  lookupDynamicFilters?: (formValues: any) => { [key: string]: any }; // Dynamic filters based on form values\n}\n\n/**\n * Form field configuration for entity form\n */\nexport interface FormFieldConfig {\n  field: string;\n  label: string;\n  type: 'text' | 'number' | 'dropdown' | 'lookup' | 'textarea' | 'enum' | 'date';\n  validators?: ValidatorFn[];\n  options?: any[];\n  required?: boolean;\n  placeholder?: string;\n  optionLabel?: string;\n  optionValue?: string;\n  min?: number;\n  max?: number;\n  minLength?: number;\n  maxLength?: number;\n  useGrouping?: boolean; // For number inputs\n  rows?: number; // For textarea\n  fullSize?: boolean; // For textarea to take full width\n  colspan?: number; // Number of columns to span (1-12, default: 6)\n  colspanWhen?: { // Conditional colspan based on other field values\n    field: string;\n    value: any;\n    colspan: number;\n  }[];\n  visibleWhen?: { // Conditional visibility\n    field: string;\n    value: any;\n  };\n  disabledWhen?: { // Conditional disabled state\n    field: string;\n    value: any;\n  };\n  defaultValue?: any; // Default value for new records\n  // Lookup specific properties\n  lookupService?: any; // Service to fetch lookup data\n  lookupDisplayField?: string; // Field to display in the lookup (default: 'name')\n  lookupDisplayFields?: string[]; // Multiple fields to display separated by ' - ' (overrides lookupDisplayField)\n  lookupValueField?: string; // Field to use as value (default: 'id')\n  lookupSearchFields?: string[]; // Fields to search in (default: ['name'])\n  lookupColumns?: LookupColumn[]; // Columns to display in lookup table\n  lookupFilters?: { [key: string]: any }; // Filters to apply when fetching lookup data\n  lookupDynamicFilters?: (formValues: any) => { [key: string]: any }; // Dynamic filters based on form values\n  // Enum specific properties\n  enumOptions?: { value: any; label: string }[]; // Options for enum fields\n  enumValues?: string[]; // Enum values array\n  enumLabels?: { [key: string]: string }; // Enum labels mapping\n  // Mask specific properties\n  useCepMask?: boolean; // Apply CEP mask to text fields\n  usePhoneMask?: boolean; // Apply phone mask to text fields\n  mask?: 'dynamic' | 'cpf' | 'cnpj' | 'cep' | 'phone' | 'document'; // Mask types\n  disabled?: boolean; // Static disabled state\n  // Date specific properties\n  dateFormat?: string; // Date format for calendar (default: 'dd/mm/yy')\n  // Number specific properties\n  minFractionDigits?: number; // Minimum fraction digits for number input\n  maxFractionDigits?: number; // Maximum fraction digits for number input\n  numberMode?: 'decimal' | 'currency'; // Number input mode\n  currency?: string; // Currency code (default: 'BRL')\n  locale?: string; // Locale for number formatting (default: 'pt-BR')\n  // Dropdown specific properties\n  showClear?: boolean; // Show clear button in dropdown\n  filter?: boolean; // Enable filter in dropdown\n  filterBy?: string; // Field to filter by in dropdown\n  // Lookup specific properties\n  lookupEntity?: string; // Entity name for lookup\n}\n\n/**\n * Entity list configuration\n */\nexport interface EntityListConfig {\n  entityName: string;\n  entityIcon: string;\n  subtitle: string;\n  columns: ColumnConfig[];\n  filters: FilterConfig[];\n  fixedFilters?: FilterConfig[]; // Filters that appear at the top, always visible\n  filterSections?: FilterSection[]; // Grouped filters in sections\n  formFields: FormFieldConfig[];\n  exportEnabled?: boolean;\n  bulkDeleteEnabled?: boolean;\n  addButtonLabel?: string;\n}\n"]}

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

@@ -0,0 +1,74 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/translation.service";
+export class TranslatePipe {
+    translationService;
+    cdr;
+    subscription;
+    lastKey;
+    lastParams;
+    lastTranslation;
+    isLoading = false;
+    constructor(translationService, cdr) {
+        this.translationService = translationService;
+        this.cdr = cdr;
+    }
+    transform(key, params) {
+        if (!key)
+            return '';
+        // Check if we need to update the translation
+        if (this.shouldUpdate(key, params)) {
+            this.updateTranslation(key, params);
+        }
+        return this.lastTranslation || key;
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    shouldUpdate(key, params) {
+        return this.lastKey !== key ||
+            JSON.stringify(this.lastParams) !== JSON.stringify(params) ||
+            !this.subscription;
+    }
+    updateTranslation(key, params) {
+        this.lastKey = key;
+        this.lastParams = params;
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+        // Aguardar carregamento das traduções se necessário
+        if (!this.translationService.isLanguageLoaded()) {
+            if (!this.isLoading) {
+                this.isLoading = true;
+                this.translationService.waitForTranslations().then(() => {
+                    this.isLoading = false;
+                    this.lastTranslation = this.translationService.translate(key, params);
+                    this.cdr.markForCheck();
+                }).catch(error => {
+                    this.isLoading = false;
+                    console.error('Error waiting for translations:', error);
+                    this.lastTranslation = key;
+                    this.cdr.markForCheck();
+                });
+            }
+            return;
+        }
+        this.subscription = this.translationService.currentLanguage$.subscribe(() => {
+            this.lastTranslation = this.translationService.translate(key, params);
+            this.cdr.markForCheck();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, deps: [{ token: i1.TranslationService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, isStandalone: true, name: "translate", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'translate',
+                    pure: false,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslationService }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,169 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./cookie.service";
+export class AuthService {
+    cookieService;
+    TOKEN_COOKIE_NAME = 'com.senior.token';
+    API_URL_COOKIE_NAME = 'com.senior.base.url';
+    API_PATH_SUFFIX = '/t/senior.com.br/bridge/1.0/rest';
+    currentUserSubject = new BehaviorSubject(null);
+    currentUser$ = this.currentUserSubject.asObservable();
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+        this.loadUserFromCookie();
+    }
+    /**
+     * Load user token from cookie
+     */
+    loadUserFromCookie() {
+        const tokenString = this.cookieService.getCookie(this.TOKEN_COOKIE_NAME);
+        if (tokenString) {
+            try {
+                const token = JSON.parse(tokenString);
+                if (this.isTokenValid(token)) {
+                    this.currentUserSubject.next(token);
+                }
+                else {
+                    this.currentUserSubject.next(null);
+                }
+            }
+            catch (error) {
+                console.error('[AuthService] Error parsing token from cookie:', error);
+                this.currentUserSubject.next(null);
+            }
+        }
+    }
+    /**
+     * Get current user token
+     */
+    getCurrentUser() {
+        return this.currentUserSubject.value;
+    }
+    /**
+     * Get access token
+     */
+    getAccessToken() {
+        const user = this.getCurrentUser();
+        return user?.access_token || null;
+    }
+    /**
+     * Get token type (e.g., "Bearer")
+     */
+    getTokenType() {
+        const user = this.getCurrentUser();
+        return user?.token_type || 'Bearer';
+    }
+    /**
+     * Get refresh token
+     */
+    getRefreshToken() {
+        const user = this.getCurrentUser();
+        return user?.refresh_token || null;
+    }
+    /**
+     * Get API base URL from cookie
+     */
+    getApiBaseUrl() {
+        const baseUrl = this.cookieService.getCookie(this.API_URL_COOKIE_NAME);
+        // In development, use proxy
+        if (!baseUrl) {
+            // Check if we're in development mode
+            const isDevelopment = !window.location.hostname.includes('senior.com.br');
+            if (isDevelopment) {
+                return '/api';
+            }
+            return null;
+        }
+        // Remove trailing slash from base URL
+        const cleanBaseUrl = baseUrl.replace(/\/$/, '');
+        // Combine with API path suffix
+        return `${cleanBaseUrl}${this.API_PATH_SUFFIX}`;
+    }
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated() {
+        const user = this.getCurrentUser();
+        return user !== null && this.isTokenValid(user);
+    }
+    /**
+     * Check if token is valid (not expired)
+     */
+    isTokenValid(token) {
+        if (!token || !token.access_token) {
+            return false;
+        }
+        // Check if token is expired
+        const now = Math.floor(Date.now() / 1000);
+        const tokenExpiry = token.expires_in;
+        // If expires_in is a timestamp, compare directly
+        // If it's a duration, we'd need the token creation time
+        // For now, assume it's a timestamp
+        // If expires_in is very large (like a duration in seconds), skip expiry check
+        if (tokenExpiry > 1000000000) {
+            // Looks like a timestamp
+            return tokenExpiry > now;
+        }
+        else {
+            // Looks like a duration, assume token is valid
+            return true;
+        }
+    }
+    /**
+     * Check if refresh token is valid
+     */
+    isRefreshTokenValid() {
+        const user = this.getCurrentUser();
+        if (!user || !user.refresh_token) {
+            return false;
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const refreshExpiry = user.refresh_expires_in;
+        return refreshExpiry > now;
+    }
+    /**
+     * Get user locale
+     */
+    getUserLocale() {
+        const user = this.getCurrentUser();
+        return user?.locale || 'pt-BR';
+    }
+    /**
+     * Get user full name
+     */
+    getUserFullName() {
+        const user = this.getCurrentUser();
+        return user?.fullName || '';
+    }
+    /**
+     * Get user email
+     */
+    getUserEmail() {
+        const user = this.getCurrentUser();
+        return user?.email || '';
+    }
+    /**
+     * Get tenant name
+     */
+    getTenantName() {
+        const user = this.getCurrentUser();
+        return user?.tenantName || '';
+    }
+    /**
+     * Get username
+     */
+    getUsername() {
+        const user = this.getCurrentUser();
+        return user?.username || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, deps: [{ token: i1.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.CookieService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../projects/components-ai/src/lib/services/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { CookieService } from './cookie.service';\n\nexport interface UserToken {\n  access_token: string;\n  expires_in: number;\n  refresh_token: string;\n  token_type: string;\n  refresh_expires_in: number;\n  username: string;\n  email: string;\n  fullName: string;\n  tenantName: string;\n  locale: string;\n  type: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AuthService {\n  private readonly TOKEN_COOKIE_NAME = 'com.senior.token';\n  private readonly API_URL_COOKIE_NAME = 'com.senior.base.url';\n  private readonly API_PATH_SUFFIX = '/t/senior.com.br/bridge/1.0/rest';\n  \n  private currentUserSubject = new BehaviorSubject<UserToken | null>(null);\n  public currentUser$ = this.currentUserSubject.asObservable();\n\n  constructor(private cookieService: CookieService) {\n    this.loadUserFromCookie();\n  }\n\n  /**\n   * Load user token from cookie\n   */\n  private loadUserFromCookie(): void {\n    const tokenString = this.cookieService.getCookie(this.TOKEN_COOKIE_NAME);\n    \n    if (tokenString) {\n      try {\n        const token = JSON.parse(tokenString) as UserToken;\n        \n        if (this.isTokenValid(token)) {\n          this.currentUserSubject.next(token);\n        } else {\n          this.currentUserSubject.next(null);\n        }\n      } catch (error) {\n        console.error('[AuthService] Error parsing token from cookie:', error);\n        this.currentUserSubject.next(null);\n      }\n    }\n  }\n\n  /**\n   * Get current user token\n   */\n  getCurrentUser(): UserToken | null {\n    return this.currentUserSubject.value;\n  }\n\n  /**\n   * Get access token\n   */\n  getAccessToken(): string | null {\n    const user = this.getCurrentUser();\n    return user?.access_token || null;\n  }\n\n  /**\n   * Get token type (e.g., \"Bearer\")\n   */\n  getTokenType(): string {\n    const user = this.getCurrentUser();\n    return user?.token_type || 'Bearer';\n  }\n\n  /**\n   * Get refresh token\n   */\n  getRefreshToken(): string | null {\n    const user = this.getCurrentUser();\n    return user?.refresh_token || null;\n  }\n\n  /**\n   * Get API base URL from cookie\n   */\n  getApiBaseUrl(): string | null {\n    const baseUrl = this.cookieService.getCookie(this.API_URL_COOKIE_NAME);\n    \n    // In development, use proxy\n    if (!baseUrl) {\n      // Check if we're in development mode\n      const isDevelopment = !window.location.hostname.includes('senior.com.br');\n      if (isDevelopment) {\n        return '/api';\n      }\n      return null;\n    }\n    \n    // Remove trailing slash from base URL\n    const cleanBaseUrl = baseUrl.replace(/\\/$/, '');\n    \n    // Combine with API path suffix\n    return `${cleanBaseUrl}${this.API_PATH_SUFFIX}`;\n  }\n\n  /**\n   * Check if user is authenticated\n   */\n  isAuthenticated(): boolean {\n    const user = this.getCurrentUser();\n    return user !== null && this.isTokenValid(user);\n  }\n\n  /**\n   * Check if token is valid (not expired)\n   */\n  private isTokenValid(token: UserToken): boolean {\n    if (!token || !token.access_token) {\n      return false;\n    }\n\n    // Check if token is expired\n    const now = Math.floor(Date.now() / 1000);\n    const tokenExpiry = token.expires_in;\n    \n    // If expires_in is a timestamp, compare directly\n    // If it's a duration, we'd need the token creation time\n    // For now, assume it's a timestamp\n    // If expires_in is very large (like a duration in seconds), skip expiry check\n    if (tokenExpiry > 1000000000) {\n      // Looks like a timestamp\n      return tokenExpiry > now;\n    } else {\n      // Looks like a duration, assume token is valid\n      return true;\n    }\n  }\n\n  /**\n   * Check if refresh token is valid\n   */\n  isRefreshTokenValid(): boolean {\n    const user = this.getCurrentUser();\n    if (!user || !user.refresh_token) {\n      return false;\n    }\n\n    const now = Math.floor(Date.now() / 1000);\n    const refreshExpiry = user.refresh_expires_in;\n    \n    return refreshExpiry > now;\n  }\n\n  /**\n   * Get user locale\n   */\n  getUserLocale(): string {\n    const user = this.getCurrentUser();\n    return user?.locale || 'pt-BR';\n  }\n\n  /**\n   * Get user full name\n   */\n  getUserFullName(): string {\n    const user = this.getCurrentUser();\n    return user?.fullName || '';\n  }\n\n  /**\n   * Get user email\n   */\n  getUserEmail(): string {\n    const user = this.getCurrentUser();\n    return user?.email || '';\n  }\n\n  /**\n   * Get tenant name\n   */\n  getTenantName(): string {\n    const user = this.getCurrentUser();\n    return user?.tenantName || '';\n  }\n\n  /**\n   * Get username\n   */\n  getUsername(): string {\n    const user = this.getCurrentUser();\n    return user?.username || '';\n  }\n}\n"]}

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

@@ -0,0 +1,90 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CookieService {
+    /**
+     * Obtém o valor de um cookie pelo nome
+     */
+    getCookie(name) {
+        if (typeof document === 'undefined') {
+            return null; // SSR protection
+        }
+        const nameEQ = name + '=';
+        const cookies = document.cookie.split(';');
+        for (let cookie of cookies) {
+            cookie = cookie.trim();
+            if (cookie.indexOf(nameEQ) === 0) {
+                const value = decodeURIComponent(cookie.substring(nameEQ.length));
+                return value;
+            }
+        }
+        return null;
+    }
+    /**
+     * Define um cookie
+     */
+    setCookie(name, value, days, path = '/') {
+        if (typeof document === 'undefined') {
+            return; // SSR protection
+        }
+        let expires = '';
+        if (days) {
+            const date = new Date();
+            date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+            expires = '; expires=' + date.toUTCString();
+        }
+        document.cookie = `${name}=${encodeURIComponent(value)}${expires}; path=${path}`;
+    }
+    /**
+     * Remove um cookie
+     */
+    deleteCookie(name, path = '/') {
+        this.setCookie(name, '', -1, path);
+    }
+    /**
+     * Verifica se um cookie existe
+     */
+    hasCookie(name) {
+        return this.getCookie(name) !== null;
+    }
+    /**
+     * Obtém todos os cookies como objeto
+     */
+    getAllCookies() {
+        if (typeof document === 'undefined') {
+            return {}; // SSR protection
+        }
+        const cookies = {};
+        const cookieArray = document.cookie.split(';');
+        for (let cookie of cookieArray) {
+            cookie = cookie.trim();
+            const [name, value] = cookie.split('=');
+            if (name && value) {
+                cookies[name] = decodeURIComponent(value);
+            }
+        }
+        return cookies;
+    }
+    /**
+     * Debug: Lista todos os cookies disponíveis
+     */
+    debugAllCookies() {
+        console.log('[CookieService] All available cookies:');
+        const allCookies = this.getAllCookies();
+        Object.keys(allCookies).forEach(name => {
+            const value = allCookies[name];
+            console.log(`[CookieService] ${name}: ${value.length > 100 ? value.substring(0, 100) + '...' : value}`);
+        });
+        if (Object.keys(allCookies).length === 0) {
+            console.log('[CookieService] No cookies found');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CookieService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CookieService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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