@aakash58/chatbot 1.1.16 → 1.1.17

package/esm2022/lib/core/services/markdown.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MarkdownService {
+    constructor() { }
+    convert(markdown) {
+        if (!markdown)
+            return '';
+        // 1. Escape HTML first to prevent XSS
+        let html = this.escapeHtml(markdown);
+        // 2. Process Heads (h1-h3)
+        // # Header -> <h1>Header</h1>
+        html = html.replace(/^### (.*$)/gim, '<h3>$1</h3>');
+        html = html.replace(/^## (.*$)/gim, '<h2>$1</h2>');
+        html = html.replace(/^# (.*$)/gim, '<h1>$1</h1>');
+        // 3. Bold (** or __)
+        html = html.replace(/\*\*(.*?)\*\*/gim, '<strong>$1</strong>');
+        html = html.replace(/__(.*?)__/gim, '<strong>$1</strong>');
+        // 4. Italic (* or _)
+        html = html.replace(/\*(.*?)\*/gim, '<em>$1</em>');
+        html = html.replace(/_(.*?)_/gim, '<em>$1</em>');
+        // 5. Lists (unordered)
+        // Note: This is a simple regex that wraps each list item in <li>.
+        // Full list wrapping <ul> needs state awareness, but for simple chat line-by-line:
+        html = html.replace(/^\s*-\s+(.*$)/gim, '<li>$1</li>');
+        html = html.replace(/^\s*\*\s+(.*$)/gim, '<li>$1</li>');
+        // 6. Lists (ordered)
+        html = html.replace(/^\s*\d+\.\s+(.*$)/gim, '<li>$1</li>');
+        // 7. Paragraphs
+        // Split by double newline to form paragraphs, but avoid wrapping existing tags
+        // This is a naive implementation; for robust parsing, we'd need a token,
+        // but for simple chat, we can just replace \n with <br> inside paragraphs.
+        // Simple line break handling
+        html = html.replace(/\n/gim, '<br>');
+        // Optional: Wrap loose text in paragraphs if completely robust is needed,
+        // but <br> is usually sufficient for chat bubbles.
+        // Wrap adjacent <li>s in <ul> or <ol> is tricky with pure regex on the whole string.
+        // Improvement: We can wrap the whole block.
+        // Basic List Wrapping (very simple heuristic)
+        // Replace sequences of <li>...</li> with <ul>...</ul> is hard without multiple passes.
+        // For now, we will style straight <li>s if they appear, or just accept that they might lack a parent <ul>
+        // which browsers often handle okay visually, OR we try to group them.
+        // Let's try to group <li>s
+        html = html.replace(/(<li>.*<\/li>(\s*<br>\s*)*)+/gim, '<ul>$&</ul>');
+        // Clean up <br> inside <ul>
+        html = html.replace(/<\/li>\s*<br>\s*<li>/gim, '</li><li>');
+        html = html.replace(/<ul>\s*<br>/gim, '<ul>');
+        html = html.replace(/<br>\s*<\/ul>/gim, '</ul>');
+        return html;
+    }
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MarkdownService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MarkdownService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MarkdownService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/theme.service.mjs

@@ -0,0 +1,248 @@
+import { effect, Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "../../app/personalization/personalization.service";
+export class ThemeService {
+    // private mediaQueryListener: ((e: MediaQueryListEvent) => void) | null = null;
+    constructor(rendererFactory, overlay, personalization) {
+        this.overlay = overlay;
+        this.personalization = personalization;
+        this._theme = signal('auto');
+        this.theme = this._theme.asReadonly();
+        this._activeTheme = signal('light-theme');
+        this.activeTheme = this._activeTheme.asReadonly();
+        this.observer = null;
+        this._currentConfig = signal(undefined);
+        this.rootElement = null;
+        this.renderer = rendererFactory.createRenderer(null, null);
+        // Sync theme and primary color with PersonalizationService
+        effect(() => {
+            const settings = this.personalization.settings();
+            const mode = settings.appearance.theme;
+            const primaryColor = settings.appearance.primaryColor;
+            // Update theme
+            this._theme.set(mode);
+            this.updateActiveTheme(mode);
+            // Update primary color globally
+            this.applyPrimaryColorToGlobal(primaryColor);
+        }, { allowSignalWrites: true });
+        // Separate effect to handle re-application of config when activeTheme changes
+        effect(() => {
+            // const currentTheme = this._activeTheme();
+            const config = this._currentConfig();
+            if (this.rootElement && config) {
+                this.applyCssVariables(this.rootElement, config);
+            }
+        });
+    }
+    setThemeConfig(config, rootElement) {
+        this._currentConfig.set(config);
+        this.rootElement = rootElement;
+        // Initial apply
+        this.applyCssVariables(rootElement, config);
+    }
+    applyPrimaryColorToGlobal(colorInput) {
+        if (!colorInput)
+            return;
+        let color = colorInput;
+        // Resolve 'default' magic string to developer default
+        if (colorInput === 'default') {
+            const defaults = this.personalization.developerDefaults();
+            color = defaults.primaryColor || 'default';
+        }
+        if (color.includes(',')) {
+            const parts = color.split(',').map((p) => p.trim());
+            const isDark = this._activeTheme() === 'dark-theme';
+            color = parts.length >= 2 ? (isDark ? parts[1] : parts[0]) : parts[0];
+        }
+        const root = document.documentElement;
+        const overlayContainer = this.overlay.getContainerElement();
+        const onPrimary = this.getContrastColor(color);
+        // Standard Material 3 tokens
+        root.style.setProperty('--mat-sys-primary', color);
+        root.style.setProperty('--mat-sys-on-primary', onPrimary);
+        // Primary Container (using semi-transparent primary as a fallback if no specific logic)
+        const primaryContainer = `${color}33`; // 20% opacity
+        root.style.setProperty('--mat-sys-primary-container', primaryContainer);
+        root.style.setProperty('--mat-sys-on-primary-container', color);
+        overlayContainer.style.setProperty('--mat-sys-primary', color);
+        overlayContainer.style.setProperty('--mat-sys-on-primary', onPrimary);
+        overlayContainer.style.setProperty('--mat-sys-primary-container', primaryContainer);
+        // Update internal legacy/utility variables
+        root.style.setProperty('--primary-color', color);
+        root.style.setProperty('--user-message-color', color);
+        root.style.setProperty('--user-text-color', onPrimary);
+        overlayContainer.style.setProperty('--primary-color', color);
+    }
+    /**
+     * Simple luminance-based contrast calculation
+     * Returns #ffffff for dark colors and #000000 for light colors
+     */
+    getContrastColor(hex) {
+        if (!hex || hex.length < 6)
+            return '#ffffff';
+        // Remove # if present
+        const cleanHex = hex.replace('#', '');
+        const r = parseInt(cleanHex.substring(0, 2), 16);
+        const g = parseInt(cleanHex.substring(2, 4), 16);
+        const b = parseInt(cleanHex.substring(4, 6), 16);
+        // Calculate luminance (standard formula)
+        const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+        return luminance > 0.6 ? '#000000' : '#ffffff';
+    }
+    setTheme(mode) {
+        this.personalization.updateAppearance({ theme: mode });
+    }
+    updateActiveTheme(mode) {
+        this.cleanupObservers();
+        if (mode === 'auto') {
+            this.handleAutoTheme();
+        }
+        else {
+            const themeToApply = mode === 'dark' ? 'dark-theme' : 'light-theme';
+            this._activeTheme.set(themeToApply);
+            this.applyThemeToGlobal(themeToApply);
+        }
+    }
+    handleAutoTheme() {
+        // Initial detection
+        this.detectAndApplyParentTheme();
+        // Watch for changes in parent
+        this.observer = new MutationObserver(() => {
+            this.detectAndApplyParentTheme();
+        });
+        this.observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ['class', 'data-theme'],
+        });
+        this.observer.observe(document.body, {
+            attributes: true,
+            attributeFilter: ['class', 'data-theme'],
+        });
+    }
+    detectAndApplyParentTheme() {
+        const isDark = this.isParentDark();
+        const newTheme = isDark ? 'dark-theme' : 'light-theme';
+        // Only update if changed to avoid unnecessary DOM updates
+        if (this._activeTheme() !== newTheme) {
+            this._activeTheme.set(newTheme);
+            this.applyThemeToGlobal(newTheme);
+        }
+    }
+    isParentDark() {
+        const body = document.body;
+        const html = document.documentElement;
+        // Check for common class names
+        const darkClasses = ['dark', 'dark-theme', 'dark-mode', 'night-mode'];
+        const hasDarkClass = (el) => darkClasses.some((c) => el.classList.contains(c));
+        if (hasDarkClass(body) || hasDarkClass(html))
+            return true;
+        // Check for data-theme attribute
+        if (body.getAttribute('data-theme') === 'dark' || html.getAttribute('data-theme') === 'dark')
+            return true;
+        //  Check for Bootstrap 5.3+ data-bs-theme
+        if (body.getAttribute('data-bs-theme') === 'dark' ||
+            html.getAttribute('data-bs-theme') === 'dark') {
+            return true;
+        }
+        // Fallback to system preference
+        // return window.matchMedia('(prefers-color-scheme: dark)').matches;
+        return false;
+    }
+    applyThemeToGlobal(theme) {
+        const overlayContainer = this.overlay.getContainerElement();
+        const root = document.documentElement;
+        // Apply to root for global CSS variables (light-dark() support)
+        this.renderer.removeClass(root, 'light-theme');
+        this.renderer.removeClass(root, 'dark-theme');
+        this.renderer.addClass(root, theme);
+        // Also apply to overlay container (for menus/dialogs)
+        this.renderer.removeClass(overlayContainer, 'light-theme');
+        this.renderer.removeClass(overlayContainer, 'dark-theme');
+        this.renderer.addClass(overlayContainer, theme);
+    }
+    cleanupObservers() {
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+    }
+    ngOnDestroy() {
+        this.cleanupObservers();
+    }
+    /**
+     * @deprecated Manual CSS variable application is now handled via theme.css tokens
+     */
+    applyCssVariables(element, config) {
+        if (!config)
+            return;
+        const isDark = this._activeTheme() === 'dark-theme';
+        const applyColor = (input, variableName) => {
+            if (input) {
+                const parts = input.split(',').map((p) => p.trim());
+                const colorToUse = parts.length >= 2 ? (isDark ? parts[1] : parts[0]) : parts[0];
+                // Apply to Component Host
+                element.style.setProperty(`--${variableName}`, colorToUse);
+                // Apply to Overlay Container (for Dialogs/Menus which exist outside host)
+                this.overlay.getContainerElement().style.setProperty(`--${variableName}`, colorToUse);
+                // Secondary mapping for specific variables that have derived states
+                // if (variableName === 'primary-color') {
+                //   element.style.setProperty('--user-message-color', colorToUse);
+                //   element.style.setProperty('--mat-sys-primary', colorToUse);
+                //   const onPrimary = this.getContrastColor(colorToUse);
+                //   element.style.setProperty('--user-text-color', onPrimary);
+                //   element.style.setProperty('--mat-sys-on-primary', onPrimary);
+                // }
+            }
+        };
+        // Font
+        if (config.fontFamily)
+            element.style.setProperty('--font-family', config.fontFamily);
+        // Primary & Secondary
+        // Handled globally via PersonalizationService/applyPrimaryColorToGlobal to allow user overrides
+        // applyColor(config.primaryColor, 'primary-color');
+        applyColor(config.secondaryColor, 'secondary-color');
+        // Backgrounds
+        applyColor(config.backgroundColor, 'background-color');
+        // Ensure chat input also follows dual mode if provided, or defaults?
+        // User only asked for background color "of the entire app".
+        applyColor(config.chatInputColor, 'chat-input-color');
+        // Text Colors
+        applyColor(config.textAltColor, 'text-alt-color');
+        applyColor(config.textColor, 'text-color');
+        applyColor(config.secondaryTextColor, 'secondary-text-color');
+        applyColor(config.hintTextColor, 'hint-text-color');
+        // Button Colors
+        applyColor(config.buttonColor, 'button-color');
+        // Message Colors
+        applyColor(config.userMessageColor, 'user-message-color');
+        applyColor(config.botMessageColor, 'bot-message-color');
+        // Message Text Colors
+        applyColor(config.userTextColor, 'user-text-color');
+        applyColor(config.botTextColor, 'bot-text-color');
+        // Borders
+        applyColor(config.borderColor, 'border-color');
+        applyColor(config.borderShadowColor, 'border-shadow-color');
+        applyColor(config.borderTopColor, 'border-top-color');
+        // Indicators
+        applyColor(config.typingIndicatorColor, 'typing-indicator-color');
+        // Utility Colors
+        applyColor(config.white, 'white');
+        applyColor(config.black, 'black');
+        applyColor(config.grey, 'grey');
+        applyColor(config.red, 'red');
+        applyColor(config.yellow, 'yellow');
+        applyColor(config.orange, 'orange');
+        applyColor(config.green, 'green');
+        applyColor(config.blue, 'blue');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, deps: [{ token: i0.RendererFactory2 }, { token: i1.OverlayContainer }, { token: i2.PersonalizationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i0.RendererFactory2 }, { type: i1.OverlayContainer }, { type: i2.PersonalizationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme.service.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/core/services/theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { effect, Injectable, OnDestroy, Renderer2, RendererFactory2, signal } from '@angular/core';\r\nimport { OverlayContainer } from '@angular/cdk/overlay';\r\nimport { DoohbotThemeConfig } from '../models/theme-config.model';\r\nimport { PersonalizationService } from '../../app/personalization/personalization.service';\r\n\r\nexport type ThemeMode = 'light' | 'dark' | 'auto';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ThemeService implements OnDestroy {\r\n  private renderer: Renderer2;\r\n  private _theme = signal<ThemeMode>('auto');\r\n  public theme = this._theme.asReadonly();\r\n\r\n  private _activeTheme = signal<'light-theme' | 'dark-theme'>('light-theme');\r\n  public activeTheme = this._activeTheme.asReadonly();\r\n\r\n  private observer: MutationObserver | null = null;\r\n  // private mediaQueryListener: ((e: MediaQueryListEvent) => void) | null = null;\r\n\r\n  constructor(\r\n    rendererFactory: RendererFactory2,\r\n    private overlay: OverlayContainer,\r\n    private personalization: PersonalizationService,\r\n  ) {\r\n    this.renderer = rendererFactory.createRenderer(null, null);\r\n\r\n    // Sync theme and primary color with PersonalizationService\r\n    effect(\r\n      () => {\r\n        const settings = this.personalization.settings();\r\n        const mode = settings.appearance.theme;\r\n        const primaryColor = settings.appearance.primaryColor;\r\n\r\n        // Update theme\r\n        this._theme.set(mode);\r\n        this.updateActiveTheme(mode);\r\n\r\n        // Update primary color globally\r\n        this.applyPrimaryColorToGlobal(primaryColor);\r\n      },\r\n      { allowSignalWrites: true },\r\n    );\r\n\r\n    // Separate effect to handle re-application of config when activeTheme changes\r\n    effect(() => {\r\n      // const currentTheme = this._activeTheme();\r\n      const config = this._currentConfig();\r\n      if (this.rootElement && config) {\r\n        this.applyCssVariables(this.rootElement, config);\r\n      }\r\n    });\r\n  }\r\n\r\n  private _currentConfig = signal<DoohbotThemeConfig | undefined>(undefined);\r\n  private rootElement: HTMLElement | null = null;\r\n\r\n  public setThemeConfig(config: DoohbotThemeConfig, rootElement: HTMLElement) {\r\n    this._currentConfig.set(config);\r\n    this.rootElement = rootElement;\r\n    // Initial apply\r\n    this.applyCssVariables(rootElement, config);\r\n  }\r\n\r\n  public applyPrimaryColorToGlobal(colorInput: string) {\r\n    if (!colorInput) return;\r\n\r\n    let color = colorInput;\r\n\r\n    // Resolve 'default' magic string to developer default\r\n    if (colorInput === 'default') {\r\n      const defaults = this.personalization.developerDefaults();\r\n      color = defaults.primaryColor || 'default';\r\n    }\r\n\r\n    if (color.includes(',')) {\r\n      const parts = color.split(',').map((p) => p.trim());\r\n      const isDark = this._activeTheme() === 'dark-theme';\r\n      color = parts.length >= 2 ? (isDark ? parts[1] : parts[0]) : parts[0];\r\n    }\r\n\r\n    const root = document.documentElement;\r\n    const overlayContainer = this.overlay.getContainerElement();\r\n    const onPrimary = this.getContrastColor(color);\r\n\r\n    // Standard Material 3 tokens\r\n    root.style.setProperty('--mat-sys-primary', color);\r\n    root.style.setProperty('--mat-sys-on-primary', onPrimary);\r\n\r\n    // Primary Container (using semi-transparent primary as a fallback if no specific logic)\r\n    const primaryContainer = `${color}33`; // 20% opacity\r\n    root.style.setProperty('--mat-sys-primary-container', primaryContainer);\r\n    root.style.setProperty('--mat-sys-on-primary-container', color);\r\n\r\n    overlayContainer.style.setProperty('--mat-sys-primary', color);\r\n    overlayContainer.style.setProperty('--mat-sys-on-primary', onPrimary);\r\n    overlayContainer.style.setProperty('--mat-sys-primary-container', primaryContainer);\r\n\r\n    // Update internal legacy/utility variables\r\n    root.style.setProperty('--primary-color', color);\r\n    root.style.setProperty('--user-message-color', color);\r\n    root.style.setProperty('--user-text-color', onPrimary);\r\n\r\n    overlayContainer.style.setProperty('--primary-color', color);\r\n  }\r\n\r\n  /**\r\n   * Simple luminance-based contrast calculation\r\n   * Returns #ffffff for dark colors and #000000 for light colors\r\n   */\r\n  private getContrastColor(hex: string): string {\r\n    if (!hex || hex.length < 6) return '#ffffff';\r\n\r\n    // Remove # if present\r\n    const cleanHex = hex.replace('#', '');\r\n    const r = parseInt(cleanHex.substring(0, 2), 16);\r\n    const g = parseInt(cleanHex.substring(2, 4), 16);\r\n    const b = parseInt(cleanHex.substring(4, 6), 16);\r\n\r\n    // Calculate luminance (standard formula)\r\n    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;\r\n\r\n    return luminance > 0.6 ? '#000000' : '#ffffff';\r\n  }\r\n\r\n  setTheme(mode: ThemeMode): void {\r\n    this.personalization.updateAppearance({ theme: mode });\r\n  }\r\n\r\n  private updateActiveTheme(mode: ThemeMode) {\r\n    this.cleanupObservers();\r\n\r\n    if (mode === 'auto') {\r\n      this.handleAutoTheme();\r\n    } else {\r\n      const themeToApply = mode === 'dark' ? 'dark-theme' : 'light-theme';\r\n      this._activeTheme.set(themeToApply);\r\n      this.applyThemeToGlobal(themeToApply);\r\n    }\r\n  }\r\n\r\n  private handleAutoTheme() {\r\n    // Initial detection\r\n    this.detectAndApplyParentTheme();\r\n\r\n    // Watch for changes in parent\r\n    this.observer = new MutationObserver(() => {\r\n      this.detectAndApplyParentTheme();\r\n    });\r\n\r\n    this.observer.observe(document.documentElement, {\r\n      attributes: true,\r\n      attributeFilter: ['class', 'data-theme'],\r\n    });\r\n    this.observer.observe(document.body, {\r\n      attributes: true,\r\n      attributeFilter: ['class', 'data-theme'],\r\n    });\r\n  }\r\n\r\n  private detectAndApplyParentTheme() {\r\n    const isDark = this.isParentDark();\r\n    const newTheme = isDark ? 'dark-theme' : 'light-theme';\r\n\r\n    // Only update if changed to avoid unnecessary DOM updates\r\n    if (this._activeTheme() !== newTheme) {\r\n      this._activeTheme.set(newTheme);\r\n      this.applyThemeToGlobal(newTheme);\r\n    }\r\n  }\r\n\r\n  private isParentDark(): boolean {\r\n    const body = document.body;\r\n    const html = document.documentElement;\r\n\r\n    // Check for common class names\r\n    const darkClasses = ['dark', 'dark-theme', 'dark-mode', 'night-mode'];\r\n    const hasDarkClass = (el: HTMLElement) => darkClasses.some((c) => el.classList.contains(c));\r\n\r\n    if (hasDarkClass(body) || hasDarkClass(html)) return true;\r\n\r\n    // Check for data-theme attribute\r\n    if (body.getAttribute('data-theme') === 'dark' || html.getAttribute('data-theme') === 'dark')\r\n      return true;\r\n\r\n    //  Check for Bootstrap 5.3+ data-bs-theme\r\n    if (\r\n      body.getAttribute('data-bs-theme') === 'dark' ||\r\n      html.getAttribute('data-bs-theme') === 'dark'\r\n    ) {\r\n      return true;\r\n    }\r\n\r\n    // Fallback to system preference\r\n    // return window.matchMedia('(prefers-color-scheme: dark)').matches;\r\n    return false;\r\n  }\r\n\r\n  private applyThemeToGlobal(theme: 'light-theme' | 'dark-theme') {\r\n    const overlayContainer = this.overlay.getContainerElement();\r\n    const root = document.documentElement;\r\n\r\n    // Apply to root for global CSS variables (light-dark() support)\r\n    this.renderer.removeClass(root, 'light-theme');\r\n    this.renderer.removeClass(root, 'dark-theme');\r\n    this.renderer.addClass(root, theme);\r\n\r\n    // Also apply to overlay container (for menus/dialogs)\r\n    this.renderer.removeClass(overlayContainer, 'light-theme');\r\n    this.renderer.removeClass(overlayContainer, 'dark-theme');\r\n    this.renderer.addClass(overlayContainer, theme);\r\n  }\r\n\r\n  private cleanupObservers() {\r\n    if (this.observer) {\r\n      this.observer.disconnect();\r\n      this.observer = null;\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.cleanupObservers();\r\n  }\r\n\r\n  /**\r\n   * @deprecated Manual CSS variable application is now handled via theme.css tokens\r\n   */\r\n  public applyCssVariables(element: HTMLElement, config: DoohbotThemeConfig | undefined) {\r\n    if (!config) return;\r\n\r\n    const isDark = this._activeTheme() === 'dark-theme';\r\n\r\n    const applyColor = (input: string | undefined, variableName: string) => {\r\n      if (input) {\r\n        const parts = input.split(',').map((p) => p.trim());\r\n        const colorToUse = parts.length >= 2 ? (isDark ? parts[1] : parts[0]) : parts[0];\r\n        // Apply to Component Host\r\n        element.style.setProperty(`--${variableName}`, colorToUse);\r\n\r\n        // Apply to Overlay Container (for Dialogs/Menus which exist outside host)\r\n        this.overlay.getContainerElement().style.setProperty(`--${variableName}`, colorToUse);\r\n\r\n        // Secondary mapping for specific variables that have derived states\r\n        // if (variableName === 'primary-color') {\r\n        //   element.style.setProperty('--user-message-color', colorToUse);\r\n        //   element.style.setProperty('--mat-sys-primary', colorToUse);\r\n        //   const onPrimary = this.getContrastColor(colorToUse);\r\n        //   element.style.setProperty('--user-text-color', onPrimary);\r\n        //   element.style.setProperty('--mat-sys-on-primary', onPrimary);\r\n        // }\r\n      }\r\n    };\r\n\r\n    // Font\r\n    if (config.fontFamily) element.style.setProperty('--font-family', config.fontFamily);\r\n\r\n    // Primary & Secondary\r\n    // Handled globally via PersonalizationService/applyPrimaryColorToGlobal to allow user overrides\r\n    // applyColor(config.primaryColor, 'primary-color');\r\n    applyColor(config.secondaryColor, 'secondary-color');\r\n\r\n    // Backgrounds\r\n    applyColor(config.backgroundColor, 'background-color');\r\n\r\n    // Ensure chat input also follows dual mode if provided, or defaults?\r\n    // User only asked for background color \"of the entire app\".\r\n    applyColor(config.chatInputColor, 'chat-input-color');\r\n\r\n    // Text Colors\r\n    applyColor(config.textAltColor, 'text-alt-color');\r\n    applyColor(config.textColor, 'text-color');\r\n    applyColor(config.secondaryTextColor, 'secondary-text-color');\r\n    applyColor(config.hintTextColor, 'hint-text-color');\r\n\r\n    // Button Colors\r\n    applyColor(config.buttonColor, 'button-color');\r\n\r\n    // Message Colors\r\n    applyColor(config.userMessageColor, 'user-message-color');\r\n    applyColor(config.botMessageColor, 'bot-message-color');\r\n\r\n    // Message Text Colors\r\n    applyColor(config.userTextColor, 'user-text-color');\r\n    applyColor(config.botTextColor, 'bot-text-color');\r\n\r\n    // Borders\r\n    applyColor(config.borderColor, 'border-color');\r\n    applyColor(config.borderShadowColor, 'border-shadow-color');\r\n    applyColor(config.borderTopColor, 'border-top-color');\r\n\r\n    // Indicators\r\n    applyColor(config.typingIndicatorColor, 'typing-indicator-color');\r\n\r\n    // Utility Colors\r\n    applyColor(config.white, 'white');\r\n    applyColor(config.black, 'black');\r\n    applyColor(config.grey, 'grey');\r\n    applyColor(config.red, 'red');\r\n    applyColor(config.yellow, 'yellow');\r\n    applyColor(config.orange, 'orange');\r\n    applyColor(config.green, 'green');\r\n    applyColor(config.blue, 'blue');\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/types/auth-mode.type.mjs

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

package/esm2022/lib/core/types/auth-status.type.mjs

@@ -0,0 +1,5 @@
+/**
+ * Authentication status
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC1zdGF0dXMudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL3R5cGVzL2F1dGgtc3RhdHVzLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQXV0aGVudGljYXRpb24gc3RhdHVzXHJcbiAqL1xyXG5cclxuZXhwb3J0IHR5cGUgQXV0aFN0YXR1cyA9ICdhdXRoZW50aWNhdGVkJyB8ICd1bmF1dGhlbnRpY2F0ZWQnIHwgJ2V4cGlyZWQnO1xyXG4iXX0=

package/esm2022/lib/core/types/chat-stream.type.mjs

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

package/esm2022/lib/core/types/message-role.type.mjs

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

package/esm2022/lib/core/types/prompt-mode.type.mjs

@@ -0,0 +1,5 @@
+/**
+ * Prompt mode
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvbXB0LW1vZGUudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL3R5cGVzL3Byb21wdC1tb2RlLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogUHJvbXB0IG1vZGVcclxuICovXHJcblxyXG5leHBvcnQgdHlwZSBQcm9tcHRNb2RlID0gJ21hcmtkb3duJyB8ICdwbGFpbic7XHJcbiJdfQ==

package/esm2022/lib/core/types/snackbar-error.type.mjs

@@ -0,0 +1,5 @@
+/**
+ * Error types for snackbar
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2tiYXItZXJyb3IudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL3R5cGVzL3NuYWNrYmFyLWVycm9yLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogRXJyb3IgdHlwZXMgZm9yIHNuYWNrYmFyXHJcbiAqL1xyXG5cclxuZXhwb3J0IHR5cGUgU25hY2tCYXJFcnJvciA9ICd3YXJuJyB8ICdlcnJvcicgfCAnc3VjY2VzcycgfCAnaW5mbyc7XHJcbiJdfQ==

package/esm2022/lib/core/types/tenant-resolution-strategy.type.mjs

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

package/esm2022/lib/core/utils/logger.service.mjs

@@ -0,0 +1,42 @@
+import { isDevMode } from '@angular/core';
+class Logger {
+    static { this.prefix = '[Doohbot]'; }
+    // 🎨 Color styles
+    static { this.styles = {
+        log: 'color:#2196f3; font-weight:500',
+        info: 'color:#4caf50; font-weight:500',
+        warn: 'color:#ff9800; font-weight:600',
+        error: 'color:#f44336; font-weight:700',
+        debug: 'color:#9c27b0; font-weight:500',
+    }; }
+    static canLog() {
+        return isDevMode();
+    }
+    static log(message, ...args) {
+        if (!this.canLog())
+            return;
+        console.log(`%c${this.prefix} ${message}`, this.styles.log, ...args);
+    }
+    static info(message, ...args) {
+        if (!this.canLog())
+            return;
+        console.info(`%c${this.prefix} ${message}`, this.styles.info, ...args);
+    }
+    static warn(message, ...args) {
+        if (!this.canLog())
+            return;
+        console.warn(`%c${this.prefix} ${message}`, this.styles.warn, ...args);
+    }
+    static error(message, ...args) {
+        if (!this.canLog())
+            return;
+        console.error(`%c${this.prefix} ${message}`, this.styles.error, ...args);
+    }
+    static debug(message, ...args) {
+        if (!this.canLog())
+            return;
+        console.debug(`%c${this.prefix} ${message}`, this.styles.debug, ...args);
+    }
+}
+export default Logger;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/doohbot-input.mjs

@@ -0,0 +1,20 @@
+export class DoohbotInput {
+    constructor() {
+        this.username = '';
+        this.password = '';
+        this.rememberMe = false;
+        this.license = '';
+        this.licenseCode = '';
+        this.licenseKey = '';
+        this.licenseFilePath = '';
+        this.apiBaseUrl = '';
+        this.apiSegment = '';
+        this.tenancyName = '';
+        this.storageKey = '';
+        this.secretKey = '';
+        this.companyCode = '';
+        this.primaryColor = '';
+        this.accentColor = '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9vaGJvdC1pbnB1dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9kb29oYm90LWlucHV0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxZQUFZO0lBQXpCO1FBQ0UsYUFBUSxHQUFHLEVBQUUsQ0FBQztRQUNkLGFBQVEsR0FBRyxFQUFFLENBQUM7UUFDZCxlQUFVLEdBQWEsS0FBSyxDQUFDO1FBRTdCLFlBQU8sR0FBWSxFQUFFLENBQUM7UUFDdEIsZ0JBQVcsR0FBWSxFQUFFLENBQUM7UUFDMUIsZUFBVSxHQUFZLEVBQUUsQ0FBQztRQUN6QixvQkFBZSxHQUFZLEVBQUUsQ0FBQztRQUM5QixlQUFVLEdBQVksRUFBRSxDQUFDO1FBQ3pCLGVBQVUsR0FBWSxFQUFFLENBQUM7UUFDekIsZ0JBQVcsR0FBWSxFQUFFLENBQUM7UUFDMUIsZUFBVSxHQUFZLEVBQUUsQ0FBQztRQUN6QixjQUFTLEdBQVksRUFBRSxDQUFDO1FBQ3hCLGdCQUFXLEdBQVksRUFBRSxDQUFDO1FBRTFCLGlCQUFZLEdBQVksRUFBRSxDQUFDO1FBQzNCLGdCQUFXLEdBQVksRUFBRSxDQUFDO0lBQzVCLENBQUM7Q0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBEb29oYm90SW5wdXQge1xyXG4gIHVzZXJuYW1lID0gJyc7XHJcbiAgcGFzc3dvcmQgPSAnJztcclxuICByZW1lbWJlck1lPzogYm9vbGVhbiA9IGZhbHNlO1xyXG4gIGF1dGhUb2tlbj86IHN0cmluZztcclxuICBsaWNlbnNlPzogc3RyaW5nID0gJyc7XHJcbiAgbGljZW5zZUNvZGU/OiBzdHJpbmcgPSAnJztcclxuICBsaWNlbnNlS2V5Pzogc3RyaW5nID0gJyc7XHJcbiAgbGljZW5zZUZpbGVQYXRoPzogc3RyaW5nID0gJyc7XHJcbiAgYXBpQmFzZVVybD86IHN0cmluZyA9ICcnO1xyXG4gIGFwaVNlZ21lbnQ/OiBzdHJpbmcgPSAnJztcclxuICB0ZW5hbmN5TmFtZT86IHN0cmluZyA9ICcnO1xyXG4gIHN0b3JhZ2VLZXk/OiBzdHJpbmcgPSAnJztcclxuICBzZWNyZXRLZXk/OiBzdHJpbmcgPSAnJztcclxuICBjb21wYW55Q29kZT86IHN0cmluZyA9ICcnO1xyXG4gIGJ1dHRvblN0eWxlPzogJ2ZhYicgfCAnc2lkZWJhcicgfCAnc2lkZWJhci10b3AnIHwgJ3NpZGViYXItYm90dG9tJztcclxuICBwcmltYXJ5Q29sb3I/OiBzdHJpbmcgPSAnJztcclxuICBhY2NlbnRDb2xvcj86IHN0cmluZyA9ICcnO1xyXG59XHJcbiJdfQ==