@opensourcekd/ng-common-libs 2.0.2 → 2.0.3

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { Observable, ReplaySubject } from 'rxjs';
-import { EventType } from 'mitt';
+import { Observable } from 'rxjs';
 
 /**
  * Event payload interface
@@ -76,84 +75,65 @@ declare const APP_CONFIG: {
 };
 
 /**
- * EventBusService - Angular service for cross-application event communication
- * Uses mitt library for efficient event handling and RxJS ReplaySubject for observable stream
- *
- * This service is designed for MicroFrontend architectures where different apps need to communicate
- * The ReplaySubject keeps last 100 events in memory for late subscribers
- *
- * **IMPORTANT for Module Federation / MicroFrontends:**
- * This service uses Angular's dependency injection with providedIn: 'root' to ensure
- * singleton behavior across all MFEs and shell when shared via Module Federation webpack config.
- *
- * Simply inject in components using Angular DI:
- *
- * @example
- * ```typescript
- * import { Component, inject, OnInit } from '@angular/core';
- * import { EventBusService } from '@opensourcekd/ng-common-libs';
- *
- * @Component({
- *   selector: 'app-example',
- *   template: '...'
- * })
- * export class ExampleComponent implements OnInit {
- *   private eventBus = inject(EventBusService);
- *
- *   ngOnInit() {
- *     // Subscribe to all events
- *     this.eventBus.onePlusNEvents.subscribe(event => {
- *       console.log('Event received:', event);
- *     });
- *   }
- *
- *   sendCustomEvent() {
- *     // Send a custom event
- *     this.eventBus.sendEvent('user:action');
+ * Auth0 Configuration
+ * Centralized configuration for Auth0 integration
+ * Framework-agnostic - works with any JavaScript framework
+ */
+/**
+ * Auth0 client configuration
+ * Override these values in your consuming application by setting them before importing AuthService
  *
- *     // Or send structured event with data
- *     this.eventBus.sendEvent(JSON.stringify({
- *       type: 'user:login',
- *       payload: { userId: '123' },
- *       timestamp: new Date().toISOString()
- *     }));
- *   }
- * }
- * ```
+ * Note: redirectUri defaults to window.location.origin (base URL without path).
+ * Auth0 will redirect back to this URL after authentication.
  */
-declare class EventBusService {
-    /**
-     * ReplaySubject that buffers the last 100 events for late subscribers
-     * Subscribe to this observable to receive all events
-     */
-    onePlusNEvents: ReplaySubject<EventType>;
-    /**
-     * mitt event emitter instance
-     * Lightweight event emitter library
-     */
-    private emitter;
-    constructor();
-    /**
-     * Send an event through the event bus
-     * The event will be forwarded to all subscribers via the ReplaySubject
-     *
-     * @param s - Event string, can be a simple event name or JSON stringified structured data
-     *
-     * @example
-     * ```typescript
-     * // Simple event
-     * eventBus.sendEvent('user:logout');
-     *
-     * // Structured event
-     * eventBus.sendEvent(JSON.stringify({
-     *   type: 'auth:token_updated',
-     *   payload: { token: 'abc123' },
-     *   timestamp: new Date().toISOString()
-     * }));
-     * ```
-     */
-    sendEvent(s: string): void;
-}
+declare const AUTH0_CONFIG: {
+    domain: string;
+    clientId: string;
+    redirectUri: string;
+    logoutUri: string;
+    audience: string;
+    scope: string;
+    connection: string | undefined;
+};
+/**
+ * Storage configuration
+ * Controls where sensitive data is stored
+ */
+declare const STORAGE_CONFIG: {
+    TOKEN_STORAGE: "localStorage" | "sessionStorage";
+    USER_INFO_STORAGE: "localStorage" | "sessionStorage";
+};
+/**
+ * Storage keys for auth data
+ */
+declare const STORAGE_KEYS: {
+    ACCESS_TOKEN: string;
+    USER_INFO: string;
+};
+/**
+ * Helper functions for storage operations
+ * These work with both localStorage and sessionStorage
+ */
+/**
+ * Get item from storage
+ * @param key - Storage key
+ * @param storageType - Type of storage to use
+ * @returns Stored value or null
+ */
+declare function getStorageItem(key: string, storageType?: 'localStorage' | 'sessionStorage'): string | null;
+/**
+ * Set item in storage
+ * @param key - Storage key
+ * @param value - Value to store
+ * @param storageType - Type of storage to use
+ */
+declare function setStorageItem(key: string, value: string, storageType?: 'localStorage' | 'sessionStorage'): void;
+/**
+ * Remove item from storage
+ * @param key - Storage key
+ * @param storageType - Type of storage to use
+ */
+declare function removeStorageItem(key: string, storageType?: 'localStorage' | 'sessionStorage'): void;
 
 /**
  * User information from ID token
@@ -215,60 +195,88 @@ interface CallbackResult {
     appState?: AppState;
 }
 /**
- * Authentication service for Auth0 integration
- * Handles login, logout, token management, and user session
- * Uses sessionStorage for sensitive data and emits authentication events for MicroApps
- *
- * Configuration is centralized in config/auth.config.ts for easy management
- *
- * **IMPORTANT for Module Federation / MicroFrontends:**
- * This service uses Angular's dependency injection with providedIn: 'root' to ensure
- * singleton behavior across all MFEs and shell when shared via Module Federation webpack config.
+ * Auth0 Configuration interface
+ */
+interface Auth0Config {
+    domain: string;
+    clientId: string;
+    redirectUri: string;
+    logoutUri: string;
+    audience?: string;
+    scope: string;
+    connection?: string;
+}
+/**
+ * Storage configuration
+ */
+interface StorageConfig {
+    TOKEN_STORAGE: 'localStorage' | 'sessionStorage';
+    USER_INFO_STORAGE: 'localStorage' | 'sessionStorage';
+}
+/**
+ * Storage keys
+ */
+interface StorageKeys {
+    ACCESS_TOKEN: string;
+    USER_INFO: string;
+}
+/**
+ * Pure TypeScript Authentication Service for Auth0 integration
+ * Framework-agnostic - works with any JavaScript framework (Angular, React, Vue, etc.)
  *
- * Simply inject in components using Angular DI:
+ * Handles login, logout, token management, and user session
+ * Uses configurable storage (sessionStorage/localStorage) for sensitive data
+ * Emits authentication events via EventBus for cross-application communication
  *
  * @example
  * ```typescript
- * import { Component, inject } from '@angular/core';
- * import { AuthService } from '@opensourcekd/ng-common-libs';
+ * import { AuthService, EventBus } from '@opensourcekd/ng-common-libs';
  *
- * @Component({
- *   selector: 'app-example',
- *   template: '...'
- * })
- * export class ExampleComponent {
- *   private authService = inject(AuthService);
- * }
- * ```
+ * // Create instances
+ * const eventBus = new EventBus();
+ * const authConfig = {
+ *   domain: 'your-domain.auth0.com',
+ *   clientId: 'your-client-id',
+ *   redirectUri: window.location.origin,
+ *   logoutUri: window.location.origin,
+ *   scope: 'openid profile email'
+ * };
+ * const authService = new AuthService(authConfig, eventBus);
  *
- * NOTE: All navigation logic using setTimeout is commented out as per requirements.
- * To enable navigation after auth operations, uncomment the marked sections in consuming components.
+ * // Use the service
+ * await authService.login();
+ * const user = authService.getUser();
+ * const token = await authService.getToken();
+ * ```
  */
 declare class AuthService {
-    private eventBus;
     private readonly STANDARD_JWT_CLAIMS;
     private auth0Client;
     private initializationPromise;
     private userSubject;
     user$: Observable<UserInfo | null>;
-    constructor(eventBus: EventBusService);
+    private config;
+    private storageConfig;
+    private storageKeys;
+    private eventBus;
+    /**
+     * Create a new AuthService instance
+     * @param config - Auth0 configuration
+     * @param eventBus - EventBus instance for emitting auth events
+     * @param storageConfig - Storage configuration (optional, defaults to sessionStorage)
+     * @param storageKeys - Storage keys (optional, defaults to standard keys)
+     */
+    constructor(config: Auth0Config, eventBus: EventBus, storageConfig?: StorageConfig, storageKeys?: StorageKeys);
     /**
      * Initialize Auth0 client
      */
     private initializeAuth0;
     /**
      * Ensure Auth0 client is initialized before use
-     * Lazy initialization pattern - client is created on first use
-     * Handles concurrent calls safely by checking promise first
      */
     private ensureInitialized;
     /**
      * Login with Auth0
-     * Redirects to Auth0 Universal Login
-     * Preserves current URL parameters (like invitation tokens) through the auth flow
-     *
-     * @param user - Optional user identifier for logging
-     * @param options - Optional login options including invitation and organization parameters
      */
     login(user?: string, options?: {
         invitation?: string;
@@ -276,228 +284,63 @@ declare class AuthService {
     }): Promise<void>;
     /**
      * Handle OAuth2 callback after successful authorization
-     * Processes the callback and retrieves user info
-     *
-     * NOTE: Navigation after successful/failed authentication should be handled in the calling component
-     * using setTimeout. See commented examples in app.component.ts
-     *
-     * @returns Promise<CallbackResult> - Success status and preserved appState
      */
     handleCallback(): Promise<CallbackResult>;
     /**
      * Log all user claims for debugging
-     * @param user - User info from Auth0
      */
     private logUserClaims;
-    /**
-     * Log standard OIDC claims
-     * @param user - User info from Auth0
-     */
     private logStandardClaims;
-    /**
-     * Log claims with consistent formatting
-     * @param header - Section header to display
-     * @param claims - Array of claim keys to log
-     * @param user - User info object
-     */
     private logClaims;
-    /**
-     * Get custom namespaced claims from user info
-     * @param user - User info object
-     * @returns Array of custom claim keys
-     */
     private getCustomClaims;
-    /**
-     * Get additional non-namespaced claims from user info
-     * @param user - User info object
-     * @returns Array of additional claim keys
-     */
     private getAdditionalClaims;
-    /**
-     * Check if a claim key is namespaced
-     * @param key - Claim key to check
-     * @returns True if the key starts with http:// or https://
-     */
     private isNamespacedClaim;
     /**
      * Logout user and clear authentication state
-     * Redirects to Auth0 logout endpoint and clears local state
      */
     logout(): Promise<void>;
     /**
-     * Get current access token from storage or Auth0 client
-     * @returns string | null - Access token or null if not authenticated
+     * Get current access token
      */
     getToken(): Promise<string | null>;
     /**
      * Get current access token synchronously from storage only
-     * Use this for synchronous operations like interceptors
-     * @returns string | null - Access token or null if not authenticated
      */
     getTokenSync(): string | null;
     /**
-     * Set access token in storage and emit event for MicroApps
-     * @param token - Access token to store
+     * Set access token in storage and emit event
      */
     private setToken;
     /**
      * Check if user is authenticated
-     * @returns boolean - True if user has valid token
      */
     isAuthenticated(): Promise<boolean>;
     /**
      * Check if user is authenticated synchronously
-     * Only checks storage, doesn't verify with Auth0
-     * @returns boolean - True if user has token in storage
      */
     isAuthenticatedSync(): boolean;
     /**
      * Get current user information
-     * @returns UserInfo | null - Current user or null if not authenticated
      */
     getUser(): UserInfo | null;
     /**
      * Get simplified user data from token
-     * Extracts user details, role, and organization from ID token claims
-     * Checks both top-level claims and namespaced custom claims
-     * @returns UserData | null - Simplified user data or null if not authenticated
      */
     getUserData(): UserData | null;
-    /**
-     * Extract claim value from user info, checking both direct properties and namespaced custom claims
-     * @param userInfo - User info object
-     * @param claimNames - Single claim name or array of claim names to search for
-     * @param defaultValue - Default value if claim is not found
-     * @returns Extracted claim value or default value
-     */
     private extractClaimValue;
     /**
      * Get user information from storage
-     * @returns UserInfo | null - Stored user info or null
      */
     private getUserInfoFromStorage;
     /**
-     * Set user information in storage, update observable and emit event for MicroApps
-     * Logs all Auth0 claims for debugging
-     * @param userInfo - User information to store
+     * Set user information in storage and update observable
      */
     private setUserInfo;
     /**
-     * Emit authentication event for MicroApps to consume
-     * Events are emitted via EventBus for cross-MFE communication
-     * @param eventType - Type of authentication event
-     * @param payload - Event payload
+     * Emit authentication event for cross-application communication
      */
     private emitAuthEvent;
 }
 
-/**
- * Auth0 Configuration
- * Centralized configuration for Auth0 integration
- *
- * Environment variables are typically set in consuming applications
- * Default values are provided for development/testing
- */
-/**
- * Auth0 client configuration
- * Override these values in your consuming application by setting them before importing AuthService
- *
- * Note: redirectUri defaults to window.location.origin (base URL without path).
- * Auth0 will redirect back to this URL after authentication.
- * You can override this to a specific callback URL (e.g., '/auth-callback') using configureAuth0().
- */
-declare const AUTH0_CONFIG: {
-    domain: string;
-    clientId: string;
-    redirectUri: string;
-    logoutUri: string;
-    audience: string;
-    scope: string;
-    connection: string | undefined;
-};
-/**
- * Storage configuration
- * Controls where sensitive data is stored
- */
-declare const STORAGE_CONFIG: {
-    TOKEN_STORAGE: "localStorage" | "sessionStorage";
-    USER_INFO_STORAGE: "localStorage" | "sessionStorage";
-};
-/**
- * Storage keys for auth data
- */
-declare const STORAGE_KEYS: {
-    ACCESS_TOKEN: string;
-    USER_INFO: string;
-};
-/**
- * Helper functions for storage operations
- * These work with both localStorage and sessionStorage
- */
-/**
- * Get item from storage
- * @param key - Storage key
- * @param storageType - Type of storage to use
- * @returns Stored value or null
- */
-declare function getStorageItem(key: string, storageType?: 'localStorage' | 'sessionStorage'): string | null;
-/**
- * Set item in storage
- * @param key - Storage key
- * @param value - Value to store
- * @param storageType - Type of storage to use
- */
-declare function setStorageItem(key: string, value: string, storageType?: 'localStorage' | 'sessionStorage'): void;
-/**
- * Remove item from storage
- * @param key - Storage key
- * @param storageType - Type of storage to use
- */
-declare function removeStorageItem(key: string, storageType?: 'localStorage' | 'sessionStorage'): void;
-/**
- * Configure Auth0 settings (OPTIONAL)
- * Call this function in your consuming application to override default Auth0 configuration.
- * Only the values you provide will be overridden; all other defaults remain unchanged.
- *
- * Note: This function is optional. If not called, default values will be used.
- *
- * @param config - Partial Auth0 configuration object with values to override
- *
- * @example
- * ```typescript
- * import { configureAuth0 } from '@opensourcekd/ng-common-libs';
- *
- * // Only override specific values - others keep their defaults
- * configureAuth0({
- *   domain: 'your-domain.auth0.com',
- *   clientId: 'your-client-id',
- *   audience: 'https://your-api.com'
- *   // redirectUri, logoutUri, scope, etc. will use defaults
- * });
- *
- * // Or override just redirectUri to use a specific callback page
- * configureAuth0({
- *   redirectUri: window.location.origin + '/auth-callback'
- * });
- * ```
- */
-/**
- * Get the API URL
- * Returns the API URL that was configured during library build from GitHub repository variables.
- * No configuration needed - the value is baked into the library during CI/CD build process.
- *
- * @returns string - The API URL from APP_CONFIG (set during build time)
- *
- * @example
- * ```typescript
- * import { getApiUrl } from '@opensourcekd/ng-common-libs';
- *
- * // Use in HTTP interceptor or service
- * const apiUrl = getApiUrl();
- * const fullUrl = `${apiUrl}/users`;
- * ```
- */
-declare function getApiUrl(): string;
-
-export { APP_CONFIG, AUTH0_CONFIG, AuthService, EventBus, EventBusService, STORAGE_CONFIG, STORAGE_KEYS, getApiUrl, getStorageItem, removeStorageItem, setStorageItem };
-export type { AppState, AuthorizationParams, CallbackResult, EventPayload, UserData, UserInfo };
+export { APP_CONFIG, AUTH0_CONFIG, AuthService, EventBus, STORAGE_CONFIG, STORAGE_KEYS, getStorageItem, removeStorageItem, setStorageItem };
+export type { AppState, Auth0Config, AuthorizationParams, CallbackResult, EventPayload, StorageConfig, StorageKeys, UserData, UserInfo };