@ramonbsales/noah-angular 1.0.0

package/lib/pages/login/login.component.d.ts

@@ -0,0 +1,82 @@
+import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { LoginService } from '../../services/login/login.service';
+import { LoginCredentials, LoginResponse, LoginStatus, LoginState, LoginOptions } from '../../types/auth.types';
+import * as i0 from "@angular/core";
+export declare class LoginComponent implements OnInit, OnDestroy {
+    private loginService;
+    private destroy$;
+    private fb;
+    options: Partial<LoginOptions>;
+    showHeader: boolean;
+    showFooter: boolean;
+    logoUrl?: string;
+    backgroundImageUrl?: string;
+    customCssClass?: string;
+    loginSuccess: EventEmitter<LoginResponse>;
+    loginError: EventEmitter<string>;
+    formChange: EventEmitter<LoginCredentials>;
+    loginForm: FormGroup;
+    loginState$: import('rxjs').Observable<LoginState>;
+    isLoading$: import('rxjs').Observable<boolean>;
+    errors$: import('rxjs').Observable<any>;
+    showPassword: boolean;
+    LoginStatus: typeof LoginStatus;
+    constructor(loginService: LoginService);
+    /**
+     * Inicializa os observables
+     */
+    private initializeObservables;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Cria o formulário reativo
+     */
+    private createForm;
+    /**
+     * Manipula mudanças de estado do login
+     */
+    private handleStateChange;
+    /**
+     * Submete o formulário de login
+     */
+    onSubmit(): Promise<void>;
+    /**
+     * Alterna visibilidade da senha
+     */
+    togglePasswordVisibility(): void;
+    /**
+     * Marca todos os campos como tocados para mostrar erros
+     */
+    private markFormGroupTouched;
+    /**
+     * Verifica se campo tem erro específico
+     */
+    hasFieldError(fieldName: string, errorType: string): boolean;
+    /**
+     * Obtém mensagem de erro do campo
+     */
+    getFieldErrorMessage(fieldName: string): string;
+    /**
+     * Obtém label do campo
+     */
+    private getFieldLabel;
+    /**
+     * Reseta o formulário
+     */
+    resetForm(): void;
+    /**
+     * Tenta fazer login com credenciais de demonstração
+     */
+    loginWithDemo(userType: 'admin' | 'professor' | 'aluno'): Promise<void>;
+    /**
+     * Manipula esqueci minha senha
+     */
+    onForgotPassword(): void;
+    /**
+     * Manipula criação de conta
+     */
+    onCreateAccount(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "lib-login", never, { "options": { "alias": "options"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "logoUrl": { "alias": "logoUrl"; "required": false; }; "backgroundImageUrl": { "alias": "backgroundImageUrl"; "required": false; }; "customCssClass": { "alias": "customCssClass"; "required": false; }; }, { "loginSuccess": "loginSuccess"; "loginError": "loginError"; "formChange": "formChange"; }, never, never, true, never>;
+}

package/lib/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './local-storage/local-storage.service';
+export * from './local-storage/auth-storage.service';
+export * from './login/login.service';

package/lib/services/local-storage/auth-storage.service.d.ts

@@ -0,0 +1,65 @@
+import { Observable } from 'rxjs';
+import { LocalStorageService } from './local-storage.service';
+import * as i0 from "@angular/core";
+export declare class AuthStorageService {
+    private storage;
+    private readonly TOKEN_KEY;
+    private readonly USER_DATA_KEY;
+    private isAuthenticated$;
+    get authState$(): Observable<boolean>;
+    constructor(storage: LocalStorageService);
+    private initAuthState;
+    /**
+     * Salva Access Token COM CRIPTOGRAFIA (backend fará todas as validações)
+     */
+    setToken(token: string, expiryInMinutes?: number): Promise<boolean>;
+    /**
+     * Recupera Access Token COM DESCRIPTOGRAFIA e validação de expiração
+     */
+    getToken(): Promise<string | null>;
+    /**
+     * Salva dados do usuário COM CRIPTOGRAFIA e validação básica
+     */
+    setUserData(userData: any): Promise<boolean>;
+    /**
+     * Recupera dados do usuário COM DESCRIPTOGRAFIA
+     */
+    getUserData<T = any>(): Promise<T | null>;
+    /**
+     * Verifica apenas se possui token (backend validará se é válido)
+     */
+    hasToken(): Promise<boolean>;
+    /**
+     * Verifica se está "aparentemente" autenticado (token existe)
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Limpa APENAS dados do cliente (não afeta refresh token no servidor)
+     */
+    clearAuthData(): void;
+    /**
+     * Decodifica payload do JWT (SEM validação - apenas para UI)
+     * IMPORTANTE: Use apenas para exibição, nunca para lógica de segurança
+     *
+     * ⚠️ ATENÇÃO: Agora requer token como parâmetro ou uso assíncrono
+     */
+    decodeTokenPayload(token?: string): any;
+    /**
+     * Versão síncrona DESATUALIZADA (tokens agora são criptografados)
+     * ⚠️ AVISO: Esta versão não funciona mais com tokens criptografados
+     * Use getToken() async para acessar tokens de forma segura
+     */
+    private getTokenSync;
+    /**
+     * Verifica se token está próximo de expirar (para UI)
+     * ⚠️ ATENÇÃO: Agora é assíncrono devido à criptografia
+     */
+    isTokenExpiringSoon(minutesThreshold?: number): Promise<boolean>;
+    /**
+     * Método utilitário: Obtém e decodifica token em uma operação
+     * Ideal para componentes que precisam dos dados do token para UI
+     */
+    getDecodedTokenData(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthStorageService>;
+}

package/lib/services/local-storage/local-storage.service.d.ts

@@ -0,0 +1,82 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export type StorageType = 'localStorage' | 'sessionStorage';
+export interface StorageOptions {
+    encrypt?: boolean;
+    compress?: boolean;
+}
+export declare class LocalStorageService {
+    private storageAvailable;
+    get storageAvailable$(): Observable<boolean>;
+    /**
+     * Salva item no storage com validação básica
+     */
+    setItem<T>(key: string, value: T, storageType?: StorageType, options?: StorageOptions): Promise<boolean>;
+    /**
+     * Recupera item do storage com tipo seguro
+     */
+    getItem<T>(key: string, storageType?: StorageType, options?: StorageOptions): Promise<T | null>;
+    /**
+     * Remove item específico
+     */
+    removeItem(key: string, storageType?: StorageType): boolean;
+    /**
+     * Limpa todo o storage
+     */
+    clear(storageType?: StorageType): boolean;
+    /**
+     * Verifica se item existe
+     */
+    hasItem(key: string, storageType?: StorageType): boolean;
+    /**
+     * Salva item com expiração
+     */
+    setItemWithExpiry<T>(key: string, value: T, expiryInMinutes: number, storageType?: StorageType): Promise<boolean>;
+    /**
+     * Recupera item com verificação de expiração
+     */
+    getItemWithExpiry<T>(key: string, storageType?: StorageType): Promise<T | null>;
+    /**
+     * Obtém todas as chaves do storage
+     */
+    getAllKeys(storageType?: StorageType): string[];
+    /**
+     * Obtém tamanho ocupado do storage em bytes (aproximado)
+     */
+    getStorageSize(storageType?: StorageType): number;
+    /**
+     * Monitor de eventos de storage
+     */
+    monitorStorageEvents(): Observable<StorageEvent>;
+    /**
+     * Limpa itens expirados do storage
+     */
+    cleanExpiredItems(storageType?: StorageType): Promise<number>;
+    /**
+     * Backup de todos os dados do storage
+     */
+    backup(storageType?: StorageType): {
+        [key: string]: any;
+    };
+    /**
+     * Restaura backup para o storage
+     */
+    restore(backup: {
+        [key: string]: any;
+    }, storageType?: StorageType): boolean;
+    /**
+     * MÉTODOS PRIVADOS SIMPLIFICADOS
+     */
+    private isStorageAvailable;
+    private getStorage;
+    private sanitizeKey;
+    private validateKey;
+    private safeJsonStringify;
+    private safeJsonParse;
+    private encryptData;
+    private decryptData;
+    private validateStorageEvent;
+    private lastEventTime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
+}

package/lib/services/login/login.service.d.ts

@@ -0,0 +1,96 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AuthProvider, LoginCredentials, LoginOptions, LoginResponse, LoginState, LoginValidationErrors, LogoutResponse, UserInfo } from '../../types/auth.types';
+import { AuthStorageService } from '../local-storage/auth-storage.service';
+import * as i0 from "@angular/core";
+/**
+ * Token de injeção para o AuthProvider
+ */
+export declare const AUTH_PROVIDER: InjectionToken<AuthProvider>;
+export declare class LoginService {
+    private authStorage;
+    private authProvider?;
+    private readonly DEFAULT_OPTIONS;
+    private loginState$;
+    private currentOptions;
+    constructor(authStorage: AuthStorageService, authProvider?: AuthProvider | undefined);
+    /**
+     * Observable do estado completo do login
+     */
+    get state$(): Observable<LoginState>;
+    /**
+     * Observable apenas do status de loading
+     */
+    get isLoading$(): Observable<boolean>;
+    /**
+     * Observable apenas do status de autenticação
+     */
+    get isAuthenticated$(): Observable<boolean>;
+    /**
+     * Observable apenas dos erros
+     */
+    get errors$(): Observable<LoginValidationErrors>;
+    /**
+     * Observable do usuário atual
+     */
+    get currentUser$(): Observable<UserInfo | null>;
+    /**
+     * Configura opções do serviço de login
+     */
+    configure(options: Partial<LoginOptions>): void;
+    /**
+     * Realiza login com as credenciais fornecidas
+     */
+    login(credentials: LoginCredentials): Promise<LoginResponse>;
+    /**
+     * Realiza logout
+     */
+    logout(): Promise<LogoutResponse>;
+    /**
+     * Verifica se o usuário atual está autenticado
+     */
+    checkAuthenticationStatus(): Promise<boolean>;
+    /**
+     * Obtém informações do usuário atual
+     */
+    getCurrentUser(): Promise<UserInfo | null>;
+    /**
+     * Verifica se token está expirando em breve
+     * ⚠️ ATENÇÃO: Agora é assíncrono devido à criptografia
+     */
+    isTokenExpiringSoon(minutesThreshold?: number): Promise<boolean>;
+    /**
+     * Limpa erros do estado atual
+     */
+    clearErrors(): void;
+    /**
+     * Reseta estado do login
+     */
+    resetLoginState(): Promise<void>;
+    /**
+     * Inicializa o serviço
+     */
+    private initializeService;
+    /**
+     * Atualiza estado reativo
+     */
+    private updateState;
+    /**
+     * Valida credenciais do formulário
+     */
+    private validateCredentials;
+    /**
+     * Trata login bem-sucedido
+     */
+    private handleSuccessfulLogin;
+    /**
+     * Trata falha de login
+     */
+    private handleFailedLogin;
+    /**
+     * Simula resposta de login para desenvolvimento/demo
+     */
+    private simulateLogin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginService>;
+}

package/lib/shared-components.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SharedComponentsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedComponentsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SharedComponentsComponent, "lib-shared-components", never, {}, {}, never, never, true, never>;
+}

package/lib/shared-components.service.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class SharedComponentsService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedComponentsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SharedComponentsService>;
+}

package/lib/sidebar/sidebar.component.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter, OnInit, OnDestroy } from '@angular/core';
+import { SidebarMenuItem, SidebarConfig, SidebarState } from '../types/sidebar.types';
+import * as i0 from "@angular/core";
+export declare class SidebarComponent implements OnInit, OnDestroy {
+    private destroy$;
+    private router;
+    config: Partial<SidebarConfig>;
+    menuItems: SidebarMenuItem[];
+    isCollapsed: boolean;
+    itemClick: EventEmitter<SidebarMenuItem>;
+    toggle: EventEmitter<boolean>;
+    overlayToggle: EventEmitter<boolean>;
+    logoClick: EventEmitter<void>;
+    private state$;
+    defaultConfig: Required<SidebarConfig>;
+    get currentState(): SidebarState;
+    get finalConfig(): Required<SidebarConfig>;
+    get sidebarWidth(): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Detecta mudanças de tela
+     */
+    onResize(event: any): void;
+    /**
+     * Inicializa o estado do sidebar
+     */
+    private initializeState;
+    /**
+     * Verifica se está em modo mobile
+     */
+    private checkMobileState;
+    /**
+     * Detecta rota ativa
+     */
+    private detectActiveRoute;
+    /**
+     * Encontra item ativo baseado na URL
+     */
+    private findActiveItem;
+    /**
+     * Atualiza o estado
+     */
+    private updateState;
+    /**
+     * Toggle do sidebar
+     */
+    toggleSidebar(): void;
+    /**
+     * Toggle do overlay (mobile)
+     */
+    toggleOverlay(): void;
+    /**
+     * Clique no item do menu
+     */
+    onItemClick(item: SidebarMenuItem, event: Event): void;
+    /**
+     * Toggle expansão de item com filhos
+     */
+    toggleItemExpansion(item: SidebarMenuItem): void;
+    /**
+     * Clique no logo
+     */
+    onLogoClick(): void;
+    /**
+     * Fecha overlay ao clicar fora (mobile)
+     */
+    closeOverlay(): void;
+    /**
+     * Verifica se item está ativo
+     */
+    isItemActive(item: SidebarMenuItem): boolean;
+    /**
+     * Verifica se item tem filhos ativos
+     */
+    hasActiveChild(item: SidebarMenuItem): boolean;
+    /**
+     * TrackBy function para performance
+     */
+    trackByItemId(index: number, item: SidebarMenuItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "lib-sidebar", never, { "config": { "alias": "config"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "isCollapsed": { "alias": "isCollapsed"; "required": false; }; }, { "itemClick": "itemClick"; "toggle": "toggle"; "overlayToggle": "overlayToggle"; "logoClick": "logoClick"; }, never, ["[slot=footer]"], true, never>;
+}

package/lib/types/auth.types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Tipos e interfaces para autenticação
+ */
+export interface LoginCredentials {
+    email: string;
+    password: string;
+}
+export interface LoginResponse {
+    success: boolean;
+    accessToken?: string;
+    user?: UserInfo;
+    expiresIn?: number;
+    message?: string;
+    errors?: string[];
+}
+export interface UserInfo {
+    id: string;
+    nome: string;
+    email: string;
+    perfil: string;
+    permissoes: string[];
+    avatar?: string;
+    lastLogin?: Date;
+}
+export interface LogoutResponse {
+    success: boolean;
+    message?: string;
+}
+export interface RefreshTokenResponse {
+    success: boolean;
+    accessToken?: string;
+    expiresIn?: number;
+    message?: string;
+}
+/**
+ * Estados do processo de login
+ */
+export declare enum LoginStatus {
+    IDLE = "IDLE",
+    LOADING = "LOADING",
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+/**
+ * Configurações opcionais para o login
+ */
+export interface LoginOptions {
+    title?: string;
+    subtitle?: string;
+    logoUrl?: string;
+    backgroundUrl?: string;
+    footerText?: string;
+    redirectUrl?: string;
+    showForgotPassword?: boolean;
+    showRegisterLink?: boolean;
+    passwordMinLength?: number;
+    links?: {
+        forgotPassword?: string;
+        register?: string;
+        termsOfService?: string;
+        privacyPolicy?: string;
+    };
+    theme?: 'light' | 'dark' | 'auto';
+    primaryColor?: string;
+}
+/**
+ * Interface que a aplicação deve implementar para comunicação com o backend
+ */
+export interface AuthProvider {
+    /**
+     * Realiza login no backend
+     */
+    login(credentials: LoginCredentials): Promise<LoginResponse>;
+    /**
+     * Realiza logout no backend
+     */
+    logout(): Promise<LogoutResponse>;
+    /**
+     * Renova o access token (opcional - se não implementado, usa apenas frontend)
+     */
+    refreshToken?(): Promise<RefreshTokenResponse>;
+    /**
+     * Verifica se o token ainda é válido no backend (opcional)
+     */
+    validateToken?(token: string): Promise<boolean>;
+}
+/**
+ * Dados de erro de validação de formulário
+ */
+export interface LoginValidationErrors {
+    email?: string[];
+    password?: string[];
+    general?: string[];
+}
+/**
+ * Estado completo do login para uso reativo
+ */
+export interface LoginState {
+    status: LoginStatus;
+    user: UserInfo | null;
+    isAuthenticated: boolean;
+    errors: LoginValidationErrors;
+    lastAttempt: Date | null;
+}

package/lib/types/sidebar.types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Interface para itens do menu lateral
+ */
+export interface SidebarMenuItem {
+    id: string;
+    label: string;
+    icon: string;
+    route?: string;
+    action?: () => void;
+    children?: SidebarMenuItem[];
+    isExpanded?: boolean;
+    isActive?: boolean;
+    disabled?: boolean;
+    badge?: string | number;
+    divider?: boolean;
+}
+/**
+ * Configurações do sidebar
+ */
+export interface SidebarConfig {
+    width?: string;
+    collapsedWidth?: string;
+    position?: 'left' | 'right';
+    collapsible?: boolean;
+    autoCollapse?: boolean;
+    overlay?: boolean;
+    logo?: {
+        src: string;
+        alt: string;
+        route?: string;
+    };
+    theme?: 'light' | 'dark';
+    customCssClass?: string;
+}
+/**
+ * Estado do sidebar
+ */
+export interface SidebarState {
+    isCollapsed: boolean;
+    isMobile: boolean;
+    isOverlayOpen: boolean;
+    activeItemId?: string;
+}
+/**
+ * Eventos emitidos pelo sidebar
+ */
+export interface SidebarEvents {
+    itemClick: SidebarMenuItem;
+    toggle: boolean;
+    overlayToggle: boolean;
+    logoClick: void;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@ramonbsales/noah-angular",
+  "version": "1.0.0",
+  "description": "Noah Angular - shared UI components",
+  "keywords": [
+    "angular",
+    "components",
+    "noah",
+    "ui"
+  ],
+  "author": "Ramon Sales <ramonbsales@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ramonborges15/noah-angular.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ramonborges15/noah-angular/issues"
+  },
+  "homepage": "https://github.com/ramonborges15/noah-angular#readme",
+  "peerDependencies": {
+    "@angular/common": "^19.2.0",
+    "@angular/core": "^19.2.0",
+    "rxjs": "^7.8.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "fesm2022/ramonbsales-noah-angular.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/ramonbsales-noah-angular.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,16 @@
+export * from './lib/shared-components.service';
+export * from './lib/shared-components.component';
+export * from './lib/components/dropdown/dropdown.component';
+export * from './lib/components/input/input.component';
+export * from './lib/components/button/button.component';
+export * from './lib/components/checkbox/checkbox.component';
+export * from './lib/components/toggle/toggle.component';
+export * from './lib/components/breadcrumb/breadcrumb.component';
+export * from './lib/components/table/table.component';
+export * from './lib/sidebar/sidebar.component';
+export * from './lib/pages/login/login.component';
+export * from './lib/services';
+export { AUTH_PROVIDER } from './lib/services/login/login.service';
+export * from './lib/interceptors';
+export * from './lib/types/auth.types';
+export * from './lib/types/sidebar.types';