@aakash58/chatbot 1.1.16 → 1.1.18

package/lib/constant/utf8.d.ts

@@ -0,0 +1,9 @@
+export declare const AppEmoji: {
+    waveHand: string;
+    robotFace: string;
+    partyPopper: string;
+    thinkingFace: string;
+    thumbsUp: string;
+    thumbsDown: string;
+    redHeart: string;
+};

package/lib/core/app-const.d.ts

@@ -0,0 +1,11 @@
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AppConst {
+    static appBaseUrl: string;
+    static data: any;
+    config$: ReplaySubject<any>;
+    constructor();
+    load(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppConst, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppConst>;
+}

package/lib/core/auth/account-api.service.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { HttpService } from '../http/http.service';
+import { AuthResult } from './models/auth-result.model';
+import { ApiResponse } from '../models/api-response.model';
+import { LoginRequest } from './models/login-request.model';
+import { FederatedLoginRequest } from './models/federated-login-request.model';
+import { StorageService } from './storage.service';
+import * as i0 from "@angular/core";
+export declare class AccountService {
+    private http;
+    private tokenStorage;
+    constructor(http: HttpService, tokenStorage: StorageService);
+    login(param?: LoginRequest, showLoader?: boolean): Observable<ApiResponse<AuthResult>>;
+    federateLogin(param?: FederatedLoginRequest, showLoader?: boolean): Observable<ApiResponse<AuthResult>>;
+    private buildLicenceHeader;
+    refreshLogin(param?: object, showLoader?: boolean): Observable<ApiResponse<AuthResult>>;
+    logout(refreshToken: string, showLoader?: boolean): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
+}

package/lib/core/auth/auth.service.d.ts

@@ -0,0 +1,90 @@
+import { CoreConfigService } from '../services/core-config.service';
+import { DoohbotInput } from '../../doohbot-input';
+import { Observable } from 'rxjs';
+import { AuthResult } from './models/auth-result.model';
+import { FederatedLoginRequest } from './models/federated-login-request.model';
+import { LoginRequest } from './models/login-request.model';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { CryptoHelperService } from '../helpers/crypto-helper.service';
+import { StorageService } from './storage.service';
+import { AuthStatus } from '../types/auth-status.type';
+import { AccountService } from './account-api.service';
+import { Router } from '@angular/router';
+import { LicensingContext } from '../models/license.model';
+import * as i0 from "@angular/core";
+declare global {
+    interface Window {
+        storageEventAdded?: boolean;
+        tabCLoseEventAdded?: boolean;
+        abp?: any;
+        AppPreBootstrap?: any;
+        AppConsts?: any;
+    }
+}
+export declare class AuthService {
+    private accountService;
+    private cryptoHelper;
+    private tokenStorage;
+    private router;
+    private coreConfig;
+    get apiUrl(): string;
+    get storageKey(): string;
+    get secretKey(): string;
+    get companyCode(): string;
+    jwtHelper: JwtHelperService;
+    private advancedConfig;
+    private authStatusSubject;
+    authStatus$: Observable<AuthStatus>;
+    isLoggingIn: import("@angular/core").WritableSignal<boolean>;
+    authError: import("@angular/core").WritableSignal<string | null>;
+    authSuccess: import("@angular/core").WritableSignal<string | null>;
+    constructor(accountService: AccountService, cryptoHelper: CryptoHelperService, tokenStorage: StorageService, router: Router, coreConfig: CoreConfigService);
+    /**
+     * Updates the service configuration from the component input
+     */
+    updateConfig(config: DoohbotInput): void;
+    getLoggedInUserName(): string;
+    getLoggedInUserImageUrl(): string | null;
+    getLoggedInUserRole(): string;
+    get authStatus(): AuthStatus;
+    /**
+     * Resolves a federated token from browser storage
+     */
+    private resolveSilentToken;
+    /**
+     * Authenticate user with federated credentials
+     */
+    federatedLogin(credentials: Partial<FederatedLoginRequest>, silent?: boolean): Promise<boolean>;
+    /**
+     * Authenticate user with credentials
+     */
+    login(credentials: LoginRequest, silent?: boolean): Promise<boolean>;
+    logout(refreshToken?: string): Promise<boolean>;
+    setSession(session: AuthResult, rememberMe?: boolean): void;
+    getOrganizationId(): string | null;
+    getRefreshToken(): string | null;
+    refreshToken(): Observable<AuthResult>;
+    isAuthenticated(): boolean;
+    isTokenExpired(): boolean;
+    /**
+     * Validate stored token on app startup
+     */
+    validateStoredToken(): Observable<AuthStatus>;
+    getUserId(): any;
+    getLicensingContext(): LicensingContext;
+    get licenseKey(): string;
+    get isFederated(): boolean;
+    setLicenseKey(key: string): void;
+    /**
+     * Clear all authentication related data from local storage, session storage, cache, and tokens.
+     * This method is called when the user logs out.
+     */
+    clearAuth(): void;
+    clearSession(): void;
+    clearTabInfo(): void;
+    clearStorage(): void;
+    clearLocalStorage(): void;
+    clearCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/lib/core/auth/models/auth-result.model.d.ts

@@ -0,0 +1,4 @@
+export declare class AuthResult {
+    access_token: string;
+    refresh_token: string;
+}

package/lib/core/auth/models/federated-login-request.model.d.ts

@@ -0,0 +1,5 @@
+export declare class FederatedLoginRequest {
+    accessToken: string;
+    rememberMe?: boolean;
+    license?: string;
+}

package/lib/core/auth/models/login-request.model.d.ts

@@ -0,0 +1,6 @@
+export declare class LoginRequest {
+    username: string;
+    password: string;
+    rememberMe?: boolean;
+    license?: string;
+}

package/lib/core/auth/storage.service.d.ts

@@ -0,0 +1,21 @@
+import { CoreConfigService } from '../services/core-config.service';
+import * as i0 from "@angular/core";
+export declare class StorageService {
+    private coreConfig;
+    get storageKey(): string;
+    get secretKey(): string;
+    private storage;
+    constructor(coreConfig: CoreConfigService);
+    setRememberMe(rememberMe: boolean): void;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    /**
+     * Check if storage is valid (can be decrypted) without side effects
+     */
+    isValid(): boolean;
+    clear(): void;
+    private encrypt;
+    private decrypt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}

package/lib/core/directives/draggable/draggable-dialog.directive.d.ts

@@ -0,0 +1,23 @@
+import { ElementRef, OnInit, Renderer2, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DraggableDialogDirective implements OnInit, OnChanges {
+    private el;
+    private renderer;
+    private isDragging;
+    private startX;
+    private startY;
+    private offsetX;
+    private offsetY;
+    dragHandleSelector: string | undefined;
+    enableDrag: boolean;
+    private dragHandle;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateDragState;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDialogDirective, "[draggableDialog]", never, { "dragHandleSelector": { "alias": "dragHandle"; "required": false; }; "enableDrag": { "alias": "enableDrag"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/core/directives/fullscreen/fullscreen.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FullscreenDirective {
+    private el;
+    private renderer;
+    private isFullScreen;
+    private preFullscreenState;
+    fullscreenTarget: string;
+    constructor(el: ElementRef, renderer: Renderer2);
+    toggle(): void;
+    getFullscreenState(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullscreenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FullscreenDirective, "[appFullscreen]", never, { "fullscreenTarget": { "alias": "fullscreenTarget"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/core/directives/resizable/resizable-dialog.directive.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef, Renderer2, OnInit, OnDestroy, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ResizableDialogDirective implements OnInit, OnDestroy, OnChanges {
+    private el;
+    private renderer;
+    private resizeHandles;
+    private activeHandle;
+    private startX;
+    private startY;
+    private startWidth;
+    private startHeight;
+    private startLeft;
+    private startTop;
+    enableResize: boolean;
+    private directions;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateResizeState;
+    ngOnDestroy(): void;
+    private setStyle;
+    private createResizeHandles;
+    private removeResizeHandles;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    private getComputedStyleValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableDialogDirective, "[resizableDialog]", never, { "enableResize": { "alias": "enableResize"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/core/environments/environment.d.ts

@@ -0,0 +1,7 @@
+export declare const environment: {
+    config: string;
+    production: boolean;
+    apiBaseUrl: string;
+    loginEndpoint: string;
+    apiSegment: string;
+};

package/lib/core/environments/environment.prod.d.ts

@@ -0,0 +1,7 @@
+export declare const environment: {
+    config: string;
+    production: boolean;
+    apiBaseUrl: string;
+    loginEndpoint: string;
+    apiSegment: string;
+};

package/lib/core/helpers/crypto-helper.service.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class CryptoHelperService {
+    private encoder;
+    private decoder;
+    private secretKey;
+    setSecretKey(key: string): void;
+    private getKey;
+    encrypt(value: string): Promise<string | null>;
+    decrypt(value: string): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CryptoHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CryptoHelperService>;
+}

package/lib/core/http/http-stream.service.d.ts

@@ -0,0 +1,18 @@
+import { NgZone } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { StorageService } from '../auth/storage.service';
+import { ChatStreamResponse } from '../../app/chat/model/chat-stream-response.model';
+import * as i0 from "@angular/core";
+export declare class HttpStreamService {
+    private ngZone;
+    private tokenStorage;
+    private http;
+    constructor(ngZone: NgZone, tokenStorage: StorageService, http: HttpClient);
+    /**
+     * Creates a POST-based HTTP streaming connection using fetch()
+     */
+    createHttpStream(url: string, body: any, headers?: Record<string, string>): Observable<ChatStreamResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpStreamService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpStreamService>;
+}

package/lib/core/http/http.service.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CoreConfigService } from '../services/core-config.service';
+import { StorageService } from '../auth/storage.service';
+import * as i0 from "@angular/core";
+export declare class HttpService {
+    private http;
+    private tokenStorage;
+    private coreConfig;
+    get apiUrl(): string;
+    constructor(http: HttpClient, tokenStorage: StorageService, coreConfig: CoreConfigService);
+    get(url: string, param?: object, nestedParam?: boolean, showLoader?: boolean, refresh?: boolean, headers?: HttpHeaders): Observable<any>;
+    private buildHttpParams;
+    post(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Observable<any>;
+    patch(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Observable<any>;
+    delete(url: string, param?: object, showLoader?: boolean, headers?: HttpHeaders): Observable<any>;
+    private returnResponse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpService>;
+}

package/lib/core/interceptors/auth.interceptor.d.ts

@@ -0,0 +1,18 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { StorageService } from '../auth/storage.service';
+import { Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AuthInterceptor implements HttpInterceptor {
+    private tokenStorage;
+    private injector;
+    private isRefreshing;
+    private clearingAuth;
+    private refreshTokenSubject;
+    constructor(tokenStorage: StorageService, injector: Injector);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    private handle401Error;
+    getRequestWithHeaders(req: HttpRequest<any>): HttpRequest<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+}

package/lib/core/interceptors/license.interceptor.d.ts

@@ -0,0 +1,11 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class LicenseInterceptor implements HttpInterceptor {
+    private injector;
+    constructor(injector: Injector);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseInterceptor>;
+}

package/lib/core/models/api-config.model.d.ts

@@ -0,0 +1,58 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Configuration for Doohbot API integration
+ */
+export interface DoohbotApiConfig {
+    /**
+     * Backend API endpoint URL
+     * Example: 'https://api.example.com/chat'
+     */
+    apiUrl: string;
+    /**
+     * Optional API key for authentication
+     */
+    apiKey?: string;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000 (30 seconds)
+     */
+    timeout?: number;
+    /**
+     * Enable API mode (true) or use local intent matching (false)
+     * @default false
+     */
+    enableApi?: boolean;
+    /**
+     * Include message history in API requests
+     * @default false
+     */
+    includeHistory?: boolean;
+    /**
+     * Maximum number of history messages to include in requests
+     * @default 10
+     */
+    maxHistoryMessages?: number;
+    /**
+     * Custom headers to include in API requests
+     */
+    customHeaders?: Record<string, string>;
+    /**
+     * Enable retry on failure
+     * @default true
+     */
+    enableRetry?: boolean;
+    /**
+     * Number of retry attempts
+     * @default 2
+     */
+    retryAttempts?: number;
+    /**
+     * Delay between retries in milliseconds
+     * @default 1000
+     */
+    retryDelay?: number;
+}
+/**
+ * Injection token for providing Doohbot API configuration
+ */
+export declare const DOOHBOT_API_CONFIG: InjectionToken<DoohbotApiConfig>;

package/lib/core/models/api-request.model.d.ts

@@ -0,0 +1,77 @@
+import { PromptMode } from '../types/prompt-mode.type';
+import { Message } from './message';
+/**
+ * Request payload for chat API
+ */
+export interface ChatApiRequest {
+    /**
+     * User's message text
+     */
+    message: string;
+    /**
+     * Prompt mode
+     */
+    prompt_mode?: PromptMode;
+    /**
+     * Optional message history for context
+     */
+    history?: Message[];
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Timestamp of the request
+     */
+    timestamp?: string;
+}
+/**
+ * Response from chat API
+ */
+export interface ChatApiResponse {
+    /**
+     * Bot's reply message
+     */
+    reply: string;
+    /**
+     * Optional confidence score (0-1)
+     */
+    confidence?: number;
+    /**
+     * Whether to show suggestion chips
+     */
+    showSuggestions?: boolean;
+    /**
+     * Optional suggested responses
+     */
+    suggestions?: string[];
+    /**
+     * Optional metadata from the API
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Optional message ID from the backend
+     */
+    messageId?: string;
+}
+/**
+ * Error response from chat API
+ */
+export interface ChatApiError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code
+     */
+    code?: string;
+    /**
+     * HTTP status code
+     */
+    statusCode?: number;
+    /**
+     * Additional error details
+     */
+    details?: any;
+}

package/lib/core/models/api-response.model.d.ts

@@ -0,0 +1,6 @@
+export declare class ApiResponse<T> {
+    success: boolean;
+    message: string;
+    data?: T;
+    constructor(success: boolean, message: string, data?: T);
+}

package/lib/core/models/doohbot-config.model.d.ts

@@ -0,0 +1,81 @@
+import { InjectionToken } from '@angular/core';
+import { AuthMode } from '../types/auth-mode.type';
+import { TenantResolutionStrategy } from '../types/tenant-resolution-strategy.type';
+import { PromptMode } from '../types/prompt-mode.type';
+/**
+ * Advanced configuration for DoohBot package
+ * Supports both simple and complex use cases
+ */
+export interface DoohbotAdvancedConfig {
+    /**
+     * Authentication mode
+     * - 'manual': You provide platformTenant, subTenant, agent manually
+     * - 'auto': Package reads from your auth service via resolver
+     * @default 'manual'
+     */
+    authMode?: AuthMode;
+    /**
+     * Tenant resolution strategy
+     * - 'static': Use fixed values provided via inputs
+     * - 'dynamic': Automatically update when auth state changes
+     * - 'callback': Use custom resolver function
+     * @default 'static'
+     */
+    tenantResolution?: TenantResolutionStrategy;
+    /**
+     * Auto-configure from localStorage key
+     * If provided, package will read auth data from localStorage
+     * Example: 'auth_user' or 'saas_session'
+     */
+    autoConfigFromStorage?: string;
+    /**
+     * Enable multi-tenant mode
+     * Allows switching between different tenant contexts
+     * @default false
+     */
+    enableMultiTenant?: boolean;
+    /**
+     * Persist chat history per tenant
+     * @default true
+     */
+    persistChatPerTenant?: boolean;
+    /**
+     * Custom authentication header name
+     * @default 'Authorization'
+     */
+    authHeaderName?: string;
+    /**
+     * Custom authentication header format
+     * Use {token} as placeholder
+     * @default 'Bearer {token}'
+     */
+    authHeaderFormat?: string;
+    /**
+     * Enable role-based features
+     * Shows/hides features based on user permissions
+     * @default false
+     */
+    enableRoleBasedFeatures?: boolean;
+    /**
+     * User permissions (for role-based features)
+     */
+    userPermissions?: string[];
+    /**
+     * Callback when authentication fails
+     */
+    onAuthFailure?: (error: any) => void;
+    /**
+     * Enable debug mode (logs configuration and requests)
+     * @default false
+     */
+    debugMode?: boolean;
+    /**
+     * Prompt mode for chat responses
+     * @default 'markdown'
+     */
+    promptMode?: PromptMode;
+}
+/**
+ * Injection token for advanced configuration
+ */
+export declare const DOOHBOT_ADVANCED_CONFIG: InjectionToken<DoohbotAdvancedConfig>;

package/lib/core/models/license.model.d.ts

@@ -0,0 +1,23 @@
+export interface LicensingContext {
+    tenantId: string;
+    principalId: string;
+    roles?: string[];
+}
+export interface LicensePackage {
+    [packageId: string]: string;
+}
+export interface SubjectLicense {
+    subjectType: 'user' | 'role' | 'tenant';
+    subjectId: string;
+    packages: LicensePackage;
+}
+export interface LicenseFileContent {
+    accountId: string;
+    issuedBy: string;
+    issuedAt: string;
+    licenses: SubjectLicense[];
+}
+export interface LicenseRegistry {
+    accountId: string;
+    subjectLicenses: Map<string, LicensePackage>;
+}

package/lib/core/models/message.d.ts

@@ -0,0 +1,16 @@
+import { MessageRole } from '../types/message-role.type';
+export interface Message {
+    id: string;
+    sender: MessageRole;
+    senderName?: string;
+    text: string;
+    chunks?: string[];
+    timestamp?: Date;
+    showSuggestions?: boolean;
+    platformTenant?: string;
+    subTenant?: string;
+    agent?: string;
+    completed: boolean | true;
+    isHistory: boolean | true;
+    copied?: boolean;
+}

package/lib/core/models/theme-config.model.d.ts

@@ -0,0 +1,28 @@
+export interface DoohbotThemeConfig {
+    fontFamily?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+    backgroundColor?: string;
+    chatInputColor?: string;
+    textAltColor?: string;
+    textColor?: string;
+    secondaryTextColor?: string;
+    hintTextColor?: string;
+    buttonColor?: string;
+    userMessageColor?: string;
+    botMessageColor?: string;
+    userTextColor?: string;
+    botTextColor?: string;
+    borderColor?: string;
+    borderShadowColor?: string;
+    borderTopColor?: string;
+    typingIndicatorColor?: string;
+    white?: string;
+    black?: string;
+    grey?: string;
+    red?: string;
+    yellow?: string;
+    orange?: string;
+    green?: string;
+    blue?: string;
+}

package/lib/core/services/core-config.service.d.ts

@@ -0,0 +1,23 @@
+import { DoohbotInput } from '../../doohbot-input';
+import * as i0 from "@angular/core";
+export declare class CoreConfigService {
+    private configSignal;
+    config$: import("@angular/core").Signal<DoohbotInput>;
+    /**
+     * Updates the global library configuration
+     */
+    updateConfig(config: DoohbotInput): void;
+    /**
+     * Dynamic getters for common config properties
+     */
+    get apiUrl(): string;
+    get storageKey(): string;
+    get secretKey(): string;
+    get companyCode(): string;
+    get tenancyName(): string;
+    get licenseKey(): string;
+    get licenseFilePath(): string;
+    get rememberMe(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoreConfigService>;
+}