@aakash58/chatbot 1.1.16 → 1.1.17

package/esm2022/lib/core/directives/draggable/draggable-dialog.directive.mjs

@@ -0,0 +1,112 @@
+import { Directive, HostListener, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DraggableDialogDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.isDragging = false;
+        this.startX = 0;
+        this.startY = 0;
+        this.offsetX = 0;
+        this.offsetY = 0;
+        this.enableDrag = false;
+    }
+    ngOnInit() {
+        this.updateDragState();
+    }
+    ngOnChanges(changes) {
+        if (changes['enableDrag']) {
+            this.updateDragState();
+        }
+    }
+    updateDragState() {
+        if (this.enableDrag) {
+            if (this.dragHandleSelector) {
+                this.dragHandle = this.el.nativeElement.querySelector(this.dragHandleSelector);
+            }
+            else {
+                this.dragHandle = this.el.nativeElement; // fallback
+            }
+            if (this.dragHandle) {
+                this.renderer.setStyle(this.dragHandle, 'cursor', 'move');
+            }
+        }
+        else {
+            if (this.dragHandle) {
+                this.renderer.setStyle(this.dragHandle, 'cursor', 'default');
+            }
+            // We don't need to unset dragHandle, just ensure the cursor is reset and the mousedown check respects the flag?
+            // Actually, the mousedown listener is always active. We should check enableDrag inside mousedown.
+        }
+    }
+    onMouseDown(event) {
+        if (!this.enableDrag)
+            return;
+        if (event.defaultPrevented)
+            return; // Respect other handlers (like resize)
+        if (!this.dragHandle)
+            return;
+        const target = event.target;
+        // Strict check if handle is explicitly provided via selector, ensuring we only drag when clicking that specific handle
+        if (this.dragHandleSelector &&
+            target !== this.dragHandle &&
+            !this.dragHandle.contains(target)) {
+            return;
+        }
+        // If using the host element as the handle (no selector), allow dragging from children
+        // BUT exclude specific interactive elements to ensure usability
+        if (!this.dragHandleSelector) {
+            // Check if target is a resize handle (has class or data-dir)
+            if (target.hasAttribute('data-dir') || target.classList.contains('doohbot-resize-handle'))
+                return;
+            if (!this.dragHandle.contains(target))
+                return;
+            // Prevent dragging when interacting with controls
+            const tagName = target.tagName;
+            if (['BUTTON', 'INPUT', 'TEXTAREA', 'A', 'SELECT', 'MAT-ICON'].includes(tagName))
+                return;
+            // Optional: explicit opt-out class
+            if (target.classList.contains('no-drag'))
+                return;
+        }
+        this.isDragging = true;
+        this.startX = event.clientX - this.offsetX;
+        this.startY = event.clientY - this.offsetY;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    }
+    onMouseMove(event) {
+        if (!this.isDragging)
+            return;
+        this.offsetX = event.clientX - this.startX;
+        this.offsetY = event.clientY - this.startY;
+        this.renderer.setStyle(this.el.nativeElement, 'transform', `translate(${this.offsetX}px, ${this.offsetY}px)`);
+    }
+    onMouseUp() {
+        this.isDragging = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DraggableDialogDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: DraggableDialogDirective, isStandalone: true, selector: "[draggableDialog]", inputs: { dragHandleSelector: ["dragHandle", "dragHandleSelector"], enableDrag: "enableDrag" }, host: { listeners: { "mousedown": "onMouseDown($event)", "document:mousemove": "onMouseMove($event)", "document:mouseup": "onMouseUp()" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DraggableDialogDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[draggableDialog]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { dragHandleSelector: [{
+                type: Input,
+                args: ['dragHandle']
+            }], enableDrag: [{
+                type: Input
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], onMouseMove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ['document:mouseup', []]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draggable-dialog.directive.js","sourceRoot":"","sources":["../../../../../../../projects/doohbot/src/lib/core/directives/draggable/draggable-dialog.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Directive,\r\n  ElementRef,\r\n  HostListener,\r\n  Input,\r\n  OnInit,\r\n  Renderer2,\r\n  OnChanges,\r\n  SimpleChanges,\r\n} from '@angular/core';\r\n\r\n@Directive({\r\n  selector: '[draggableDialog]',\r\n  standalone: true,\r\n})\r\nexport class DraggableDialogDirective implements OnInit, OnChanges {\r\n  private isDragging = false;\r\n  private startX = 0;\r\n  private startY = 0;\r\n  private offsetX = 0;\r\n  private offsetY = 0;\r\n\r\n  @Input('dragHandle') dragHandleSelector: string | undefined;\r\n  @Input() enableDrag = false;\r\n\r\n  private dragHandle: HTMLElement | undefined;\r\n\r\n  constructor(\r\n    private el: ElementRef,\r\n    private renderer: Renderer2,\r\n  ) {}\r\n\r\n  ngOnInit() {\r\n    this.updateDragState();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    if (changes['enableDrag']) {\r\n      this.updateDragState();\r\n    }\r\n  }\r\n\r\n  private updateDragState() {\r\n    if (this.enableDrag) {\r\n      if (this.dragHandleSelector) {\r\n        this.dragHandle = this.el.nativeElement.querySelector(this.dragHandleSelector);\r\n      } else {\r\n        this.dragHandle = this.el.nativeElement; // fallback\r\n      }\r\n      if (this.dragHandle) {\r\n        this.renderer.setStyle(this.dragHandle, 'cursor', 'move');\r\n      }\r\n    } else {\r\n      if (this.dragHandle) {\r\n        this.renderer.setStyle(this.dragHandle, 'cursor', 'default');\r\n      }\r\n      // We don't need to unset dragHandle, just ensure the cursor is reset and the mousedown check respects the flag?\r\n      // Actually, the mousedown listener is always active. We should check enableDrag inside mousedown.\r\n    }\r\n  }\r\n\r\n  @HostListener('mousedown', ['$event'])\r\n  onMouseDown(event: MouseEvent) {\r\n    if (!this.enableDrag) return;\r\n    if (event.defaultPrevented) return; // Respect other handlers (like resize)\r\n\r\n    if (!this.dragHandle) return;\r\n\r\n    const target = event.target as HTMLElement;\r\n\r\n    // Strict check if handle is explicitly provided via selector, ensuring we only drag when clicking that specific handle\r\n    if (\r\n      this.dragHandleSelector &&\r\n      target !== this.dragHandle &&\r\n      !this.dragHandle.contains(target)\r\n    ) {\r\n      return;\r\n    }\r\n\r\n    // If using the host element as the handle (no selector), allow dragging from children\r\n    // BUT exclude specific interactive elements to ensure usability\r\n    if (!this.dragHandleSelector) {\r\n      // Check if target is a resize handle (has class or data-dir)\r\n      if (target.hasAttribute('data-dir') || target.classList.contains('doohbot-resize-handle'))\r\n        return;\r\n\r\n      if (!this.dragHandle.contains(target)) return;\r\n\r\n      // Prevent dragging when interacting with controls\r\n      const tagName = target.tagName;\r\n      if (['BUTTON', 'INPUT', 'TEXTAREA', 'A', 'SELECT', 'MAT-ICON'].includes(tagName)) return;\r\n\r\n      // Optional: explicit opt-out class\r\n      if (target.classList.contains('no-drag')) return;\r\n    }\r\n\r\n    this.isDragging = true;\r\n    this.startX = event.clientX - this.offsetX;\r\n    this.startY = event.clientY - this.offsetY;\r\n\r\n    event.preventDefault();\r\n    event.stopImmediatePropagation();\r\n  }\r\n\r\n  @HostListener('document:mousemove', ['$event'])\r\n  onMouseMove(event: MouseEvent) {\r\n    if (!this.isDragging) return;\r\n\r\n    this.offsetX = event.clientX - this.startX;\r\n    this.offsetY = event.clientY - this.startY;\r\n\r\n    this.renderer.setStyle(\r\n      this.el.nativeElement,\r\n      'transform',\r\n      `translate(${this.offsetX}px, ${this.offsetY}px)`,\r\n    );\r\n  }\r\n\r\n  @HostListener('document:mouseup', [])\r\n  onMouseUp() {\r\n    this.isDragging = false;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/directives/fullscreen/fullscreen.directive.mjs

@@ -0,0 +1,55 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FullscreenDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.isFullScreen = false;
+        this.preFullscreenState = null;
+        this.fullscreenTarget = '.chat-window';
+    }
+    toggle() {
+        const targetEl = this.el.nativeElement.querySelector(this.fullscreenTarget);
+        if (!targetEl)
+            return;
+        if (!this.isFullScreen) {
+            this.preFullscreenState = {
+                width: targetEl.style.width,
+                height: targetEl.style.height,
+                left: targetEl.style.left,
+                top: targetEl.style.top,
+            };
+            targetEl.style.width = '';
+            targetEl.style.height = '';
+            targetEl.style.left = '';
+            targetEl.style.top = '';
+            targetEl.style.transform = '';
+            this.isFullScreen = true;
+        }
+        else {
+            this.isFullScreen = false;
+            if (this.preFullscreenState) {
+                targetEl.style.width = this.preFullscreenState.width;
+                targetEl.style.height = this.preFullscreenState.height;
+                targetEl.style.left = this.preFullscreenState.left;
+                targetEl.style.top = this.preFullscreenState.top;
+                targetEl.style.transform = ''; // Clear transform to allow CSS transitions/classes
+            }
+        }
+    }
+    getFullscreenState() {
+        return this.isFullScreen;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FullscreenDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: FullscreenDirective, isStandalone: true, selector: "[appFullscreen]", inputs: { fullscreenTarget: "fullscreenTarget" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FullscreenDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appFullscreen]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { fullscreenTarget: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/directives/resizable/resizable-dialog.directive.mjs

@@ -0,0 +1,179 @@
+// resizable-dialog.directive.ts
+import { Directive, HostListener, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ResizableDialogDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.resizeHandles = [];
+        this.activeHandle = null;
+        this.startX = 0;
+        this.startY = 0;
+        this.startWidth = 0;
+        this.startHeight = 0;
+        this.startLeft = 0;
+        this.startTop = 0;
+        this.enableResize = false;
+        // Define resize directions
+        this.directions = ['n', 's', 'e', 'w', 'ne', 'nw', 'se', 'sw'];
+    }
+    ngOnInit() {
+        this.updateResizeState();
+    }
+    ngOnChanges(changes) {
+        if (changes['enableResize']) {
+            this.updateResizeState();
+        }
+    }
+    updateResizeState() {
+        if (this.enableResize) {
+            if (this.resizeHandles.length === 0) {
+                this.setStyle();
+                this.createResizeHandles();
+            }
+        }
+        else {
+            this.removeResizeHandles();
+        }
+    }
+    ngOnDestroy() {
+        this.removeResizeHandles();
+    }
+    setStyle() {
+        const element = this.el.nativeElement;
+        this.renderer.setStyle(element, 'position', 'absolute');
+        this.renderer.setStyle(element, 'overflow', 'hidden');
+        this.renderer.setStyle(element, 'boxSizing', 'border-box');
+    }
+    createResizeHandles() {
+        this.directions.forEach((dir) => {
+            const handle = this.renderer.createElement('div');
+            this.renderer.setAttribute(handle, 'data-dir', dir);
+            this.renderer.addClass(handle, 'doohbot-resize-handle');
+            this.renderer.setStyle(handle, 'position', 'absolute');
+            this.renderer.setStyle(handle, 'background', 'transparent');
+            this.renderer.setStyle(handle, 'zIndex', '2000'); // High z-index to sit above content
+            this.renderer.setStyle(handle, 'userSelect', 'none');
+            // Set size and position based on direction
+            if (dir.includes('e') || dir.includes('w')) {
+                this.renderer.setStyle(handle, 'width', '15px'); // Slightly larger hit area
+                this.renderer.setStyle(handle, 'cursor', dir.includes('e') ? 'e-resize' : 'w-resize');
+                this.renderer.setStyle(handle, 'top', '0');
+                this.renderer.setStyle(handle, 'bottom', '0');
+                this.renderer.setStyle(handle, 'right', dir.includes('e') ? '-5px' : null); // Extend slightly out
+                this.renderer.setStyle(handle, 'left', dir.includes('w') ? '-5px' : null);
+            }
+            if (dir.includes('n') || dir.includes('s')) {
+                this.renderer.setStyle(handle, 'height', '15px');
+                this.renderer.setStyle(handle, 'cursor', dir.includes('s') ? 's-resize' : 'n-resize');
+                this.renderer.setStyle(handle, 'left', '0');
+                this.renderer.setStyle(handle, 'right', '0');
+                this.renderer.setStyle(handle, 'bottom', dir.includes('s') ? '-5px' : null);
+                this.renderer.setStyle(handle, 'top', dir.includes('n') ? '-5px' : null);
+            }
+            if (dir === 'ne' || dir === 'nw' || dir === 'se' || dir === 'sw') {
+                this.renderer.setStyle(handle, 'width', '20px');
+                this.renderer.setStyle(handle, 'height', '20px');
+                this.renderer.setStyle(handle, 'borderRadius', '50%');
+                this.renderer.setStyle(handle, 'cursor', `${dir}-resize`);
+                this.renderer.setStyle(handle, 'top', dir.includes('n') ? '-10px' : null);
+                this.renderer.setStyle(handle, 'bottom', dir.includes('s') ? '-10px' : null);
+                this.renderer.setStyle(handle, 'left', dir.includes('w') ? '-10px' : null);
+                this.renderer.setStyle(handle, 'right', dir.includes('e') ? '-10px' : null);
+            }
+            this.renderer.appendChild(this.el.nativeElement, handle);
+            this.resizeHandles.push(handle);
+        });
+    }
+    removeResizeHandles() {
+        this.resizeHandles.forEach((handle) => {
+            this.renderer.removeChild(this.el.nativeElement, handle);
+        });
+        this.resizeHandles = [];
+    }
+    onMouseDown(event) {
+        if (!this.enableResize)
+            return;
+        if (event.defaultPrevented)
+            return; // Respect other handlers
+        const target = event.target;
+        const dir = target.getAttribute('data-dir');
+        if (!dir)
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        this.activeHandle = dir;
+        const rect = this.el.nativeElement.getBoundingClientRect();
+        this.startX = event.clientX;
+        this.startY = event.clientY;
+        this.startWidth = parseFloat(this.getComputedStyleValue('width'));
+        this.startHeight = parseFloat(this.getComputedStyleValue('height'));
+        this.startLeft = parseFloat(this.getComputedStyleValue('left'));
+        this.startTop = parseFloat(this.getComputedStyleValue('top'));
+        // Prevent text selection during resize
+        document.body.classList.add('no-select');
+    }
+    onMouseMove(event) {
+        if (!this.activeHandle)
+            return;
+        const dx = event.clientX - this.startX;
+        const dy = event.clientY - this.startY;
+        let newWidth = this.startWidth;
+        let newHeight = this.startHeight;
+        let newLeft = this.startLeft;
+        let newTop = this.startTop;
+        const minWidth = 150;
+        const minHeight = 100;
+        // Horizontal resize
+        if (this.activeHandle.includes('e')) {
+            newWidth = Math.max(this.startWidth + dx, minWidth);
+        }
+        if (this.activeHandle.includes('w')) {
+            newWidth = Math.max(this.startWidth - dx, minWidth);
+            newLeft = this.startLeft + (this.startWidth - newWidth);
+        }
+        // Vertical resize
+        if (this.activeHandle.includes('s')) {
+            newHeight = Math.max(this.startHeight + dy, minHeight);
+        }
+        if (this.activeHandle.includes('n')) {
+            newHeight = Math.max(this.startHeight - dy, minHeight);
+            newTop = this.startTop + (this.startHeight - newHeight);
+        }
+        // Apply changes
+        this.renderer.setStyle(this.el.nativeElement, 'width', `${newWidth}px`);
+        this.renderer.setStyle(this.el.nativeElement, 'height', `${newHeight}px`);
+        this.renderer.setStyle(this.el.nativeElement, 'left', `${newLeft}px`);
+        this.renderer.setStyle(this.el.nativeElement, 'top', `${newTop}px`);
+    }
+    onMouseUp() {
+        if (this.activeHandle) {
+            this.activeHandle = null;
+            document.body.classList.remove('no-select');
+        }
+    }
+    getComputedStyleValue(property) {
+        return getComputedStyle(this.el.nativeElement).getPropertyValue(property) || '0';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResizableDialogDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ResizableDialogDirective, isStandalone: true, selector: "[resizableDialog]", inputs: { enableResize: "enableResize" }, host: { listeners: { "mousedown": "onMouseDown($event)", "document:mousemove": "onMouseMove($event)", "document:mouseup": "onMouseUp()" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResizableDialogDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[resizableDialog]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { enableResize: [{
+                type: Input
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], onMouseMove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ['document:mouseup']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizable-dialog.directive.js","sourceRoot":"","sources":["../../../../../../../projects/doohbot/src/lib/core/directives/resizable/resizable-dialog.directive.ts"],"names":[],"mappings":"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","sourcesContent":["// resizable-dialog.directive.ts\r\nimport {\r\n  Directive,\r\n  ElementRef,\r\n  Renderer2,\r\n  OnInit,\r\n  OnDestroy,\r\n  HostListener,\r\n  Input,\r\n  OnChanges,\r\n  SimpleChanges,\r\n} from '@angular/core';\r\n\r\n@Directive({\r\n  selector: '[resizableDialog]',\r\n  standalone: true,\r\n})\r\nexport class ResizableDialogDirective implements OnInit, OnDestroy, OnChanges {\r\n  private resizeHandles: HTMLElement[] = [];\r\n  private activeHandle: string | null = null;\r\n  private startX = 0;\r\n  private startY = 0;\r\n  private startWidth = 0;\r\n  private startHeight = 0;\r\n  private startLeft = 0;\r\n  private startTop = 0;\r\n\r\n  @Input() enableResize = false;\r\n\r\n  // Define resize directions\r\n  private directions = ['n', 's', 'e', 'w', 'ne', 'nw', 'se', 'sw'];\r\n\r\n  constructor(\r\n    private el: ElementRef<HTMLElement>,\r\n    private renderer: Renderer2,\r\n  ) {}\r\n\r\n  ngOnInit() {\r\n    this.updateResizeState();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    if (changes['enableResize']) {\r\n      this.updateResizeState();\r\n    }\r\n  }\r\n\r\n  private updateResizeState() {\r\n    if (this.enableResize) {\r\n      if (this.resizeHandles.length === 0) {\r\n        this.setStyle();\r\n        this.createResizeHandles();\r\n      }\r\n    } else {\r\n      this.removeResizeHandles();\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.removeResizeHandles();\r\n  }\r\n\r\n  private setStyle() {\r\n    const element = this.el.nativeElement;\r\n    this.renderer.setStyle(element, 'position', 'absolute');\r\n    this.renderer.setStyle(element, 'overflow', 'hidden');\r\n    this.renderer.setStyle(element, 'boxSizing', 'border-box');\r\n  }\r\n\r\n  private createResizeHandles() {\r\n    this.directions.forEach((dir) => {\r\n      const handle = this.renderer.createElement('div');\r\n      this.renderer.setAttribute(handle, 'data-dir', dir);\r\n      this.renderer.addClass(handle, 'doohbot-resize-handle');\r\n      this.renderer.setStyle(handle, 'position', 'absolute');\r\n      this.renderer.setStyle(handle, 'background', 'transparent');\r\n      this.renderer.setStyle(handle, 'zIndex', '2000'); // High z-index to sit above content\r\n      this.renderer.setStyle(handle, 'userSelect', 'none');\r\n\r\n      // Set size and position based on direction\r\n      if (dir.includes('e') || dir.includes('w')) {\r\n        this.renderer.setStyle(handle, 'width', '15px'); // Slightly larger hit area\r\n        this.renderer.setStyle(handle, 'cursor', dir.includes('e') ? 'e-resize' : 'w-resize');\r\n        this.renderer.setStyle(handle, 'top', '0');\r\n        this.renderer.setStyle(handle, 'bottom', '0');\r\n        this.renderer.setStyle(handle, 'right', dir.includes('e') ? '-5px' : null); // Extend slightly out\r\n        this.renderer.setStyle(handle, 'left', dir.includes('w') ? '-5px' : null);\r\n      }\r\n      if (dir.includes('n') || dir.includes('s')) {\r\n        this.renderer.setStyle(handle, 'height', '15px');\r\n        this.renderer.setStyle(handle, 'cursor', dir.includes('s') ? 's-resize' : 'n-resize');\r\n        this.renderer.setStyle(handle, 'left', '0');\r\n        this.renderer.setStyle(handle, 'right', '0');\r\n        this.renderer.setStyle(handle, 'bottom', dir.includes('s') ? '-5px' : null);\r\n        this.renderer.setStyle(handle, 'top', dir.includes('n') ? '-5px' : null);\r\n      }\r\n      if (dir === 'ne' || dir === 'nw' || dir === 'se' || dir === 'sw') {\r\n        this.renderer.setStyle(handle, 'width', '20px');\r\n        this.renderer.setStyle(handle, 'height', '20px');\r\n        this.renderer.setStyle(handle, 'borderRadius', '50%');\r\n        this.renderer.setStyle(handle, 'cursor', `${dir}-resize`);\r\n        this.renderer.setStyle(handle, 'top', dir.includes('n') ? '-10px' : null);\r\n        this.renderer.setStyle(handle, 'bottom', dir.includes('s') ? '-10px' : null);\r\n        this.renderer.setStyle(handle, 'left', dir.includes('w') ? '-10px' : null);\r\n        this.renderer.setStyle(handle, 'right', dir.includes('e') ? '-10px' : null);\r\n      }\r\n\r\n      this.renderer.appendChild(this.el.nativeElement, handle);\r\n      this.resizeHandles.push(handle);\r\n    });\r\n  }\r\n\r\n  private removeResizeHandles() {\r\n    this.resizeHandles.forEach((handle) => {\r\n      this.renderer.removeChild(this.el.nativeElement, handle);\r\n    });\r\n    this.resizeHandles = [];\r\n  }\r\n\r\n  @HostListener('mousedown', ['$event'])\r\n  onMouseDown(event: MouseEvent) {\r\n    if (!this.enableResize) return;\r\n    if (event.defaultPrevented) return; // Respect other handlers\r\n\r\n    const target = event.target as HTMLElement;\r\n    const dir = target.getAttribute('data-dir');\r\n    if (!dir) return;\r\n\r\n    event.preventDefault();\r\n    event.stopImmediatePropagation();\r\n\r\n    this.activeHandle = dir;\r\n    const rect = this.el.nativeElement.getBoundingClientRect();\r\n\r\n    this.startX = event.clientX;\r\n    this.startY = event.clientY;\r\n    this.startWidth = parseFloat(this.getComputedStyleValue('width'));\r\n    this.startHeight = parseFloat(this.getComputedStyleValue('height'));\r\n    this.startLeft = parseFloat(this.getComputedStyleValue('left'));\r\n    this.startTop = parseFloat(this.getComputedStyleValue('top'));\r\n\r\n    // Prevent text selection during resize\r\n    document.body.classList.add('no-select');\r\n  }\r\n\r\n  @HostListener('document:mousemove', ['$event'])\r\n  onMouseMove(event: MouseEvent) {\r\n    if (!this.activeHandle) return;\r\n\r\n    const dx = event.clientX - this.startX;\r\n    const dy = event.clientY - this.startY;\r\n\r\n    let newWidth = this.startWidth;\r\n    let newHeight = this.startHeight;\r\n    let newLeft = this.startLeft;\r\n    let newTop = this.startTop;\r\n\r\n    const minWidth = 150;\r\n    const minHeight = 100;\r\n\r\n    // Horizontal resize\r\n    if (this.activeHandle.includes('e')) {\r\n      newWidth = Math.max(this.startWidth + dx, minWidth);\r\n    }\r\n    if (this.activeHandle.includes('w')) {\r\n      newWidth = Math.max(this.startWidth - dx, minWidth);\r\n      newLeft = this.startLeft + (this.startWidth - newWidth);\r\n    }\r\n\r\n    // Vertical resize\r\n    if (this.activeHandle.includes('s')) {\r\n      newHeight = Math.max(this.startHeight + dy, minHeight);\r\n    }\r\n    if (this.activeHandle.includes('n')) {\r\n      newHeight = Math.max(this.startHeight - dy, minHeight);\r\n      newTop = this.startTop + (this.startHeight - newHeight);\r\n    }\r\n\r\n    // Apply changes\r\n    this.renderer.setStyle(this.el.nativeElement, 'width', `${newWidth}px`);\r\n    this.renderer.setStyle(this.el.nativeElement, 'height', `${newHeight}px`);\r\n    this.renderer.setStyle(this.el.nativeElement, 'left', `${newLeft}px`);\r\n    this.renderer.setStyle(this.el.nativeElement, 'top', `${newTop}px`);\r\n  }\r\n\r\n  @HostListener('document:mouseup')\r\n  onMouseUp() {\r\n    if (this.activeHandle) {\r\n      this.activeHandle = null;\r\n      document.body.classList.remove('no-select');\r\n    }\r\n  }\r\n\r\n  private getComputedStyleValue(property: string): string {\r\n    return getComputedStyle(this.el.nativeElement).getPropertyValue(property) || '0';\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/environments/environment.mjs

@@ -0,0 +1,15 @@
+// export const environment = {
+//   staging: false,
+//   development: false,
+//   production: true,
+//   chatApiUrl: 'https://api.production.com',
+//   apiKey: '',
+// };
+export const environment = {
+    config: 'const/app-const.json',
+    production: false,
+    apiBaseUrl: '',
+    loginEndpoint: '',
+    apiSegment: 'api/v1/',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kb29oYm90L3NyYy9saWIvY29yZS9lbnZpcm9ubWVudHMvZW52aXJvbm1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQStCO0FBQy9CLG9CQUFvQjtBQUNwQix3QkFBd0I7QUFDeEIsc0JBQXNCO0FBQ3RCLDhDQUE4QztBQUM5QyxnQkFBZ0I7QUFDaEIsS0FBSztBQUNMLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRztJQUN6QixNQUFNLEVBQUUsc0JBQXNCO0lBQzlCLFVBQVUsRUFBRSxLQUFLO0lBQ2pCLFVBQVUsRUFBRSxFQUFFO0lBQ2QsYUFBYSxFQUFFLEVBQUU7SUFDakIsVUFBVSxFQUFFLFNBQVM7Q0FDdEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIGV4cG9ydCBjb25zdCBlbnZpcm9ubWVudCA9IHtcclxuLy8gICBzdGFnaW5nOiBmYWxzZSxcclxuLy8gICBkZXZlbG9wbWVudDogZmFsc2UsXHJcbi8vICAgcHJvZHVjdGlvbjogdHJ1ZSxcclxuLy8gICBjaGF0QXBpVXJsOiAnaHR0cHM6Ly9hcGkucHJvZHVjdGlvbi5jb20nLFxyXG4vLyAgIGFwaUtleTogJycsXHJcbi8vIH07XHJcbmV4cG9ydCBjb25zdCBlbnZpcm9ubWVudCA9IHtcclxuICBjb25maWc6ICdjb25zdC9hcHAtY29uc3QuanNvbicsXHJcbiAgcHJvZHVjdGlvbjogZmFsc2UsXHJcbiAgYXBpQmFzZVVybDogJycsXHJcbiAgbG9naW5FbmRwb2ludDogJycsXHJcbiAgYXBpU2VnbWVudDogJ2FwaS92MS8nLFxyXG59O1xyXG4iXX0=

package/esm2022/lib/core/environments/environment.prod.mjs

@@ -0,0 +1,15 @@
+// export const environment = {
+//   staging: false,
+//   development: false,
+//   production: true,
+//   chatApiUrl: 'https://api.production.com',
+//   apiKey: '',
+// };
+export const environment = {
+    config: 'const/app-const.prod.json',
+    production: true,
+    apiBaseUrl: '',
+    loginEndpoint: '',
+    apiSegment: 'api/v1/',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQucHJvZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL2Vudmlyb25tZW50cy9lbnZpcm9ubWVudC5wcm9kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtCQUErQjtBQUMvQixvQkFBb0I7QUFDcEIsd0JBQXdCO0FBQ3hCLHNCQUFzQjtBQUN0Qiw4Q0FBOEM7QUFDOUMsZ0JBQWdCO0FBQ2hCLEtBQUs7QUFDTCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUc7SUFDekIsTUFBTSxFQUFFLDJCQUEyQjtJQUNuQyxVQUFVLEVBQUUsSUFBSTtJQUNoQixVQUFVLEVBQUUsRUFBRTtJQUNkLGFBQWEsRUFBRSxFQUFFO0lBQ2pCLFVBQVUsRUFBRSxTQUFTO0NBQ3RCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBleHBvcnQgY29uc3QgZW52aXJvbm1lbnQgPSB7XHJcbi8vICAgc3RhZ2luZzogZmFsc2UsXHJcbi8vICAgZGV2ZWxvcG1lbnQ6IGZhbHNlLFxyXG4vLyAgIHByb2R1Y3Rpb246IHRydWUsXHJcbi8vICAgY2hhdEFwaVVybDogJ2h0dHBzOi8vYXBpLnByb2R1Y3Rpb24uY29tJyxcclxuLy8gICBhcGlLZXk6ICcnLFxyXG4vLyB9O1xyXG5leHBvcnQgY29uc3QgZW52aXJvbm1lbnQgPSB7XHJcbiAgY29uZmlnOiAnY29uc3QvYXBwLWNvbnN0LnByb2QuanNvbicsXHJcbiAgcHJvZHVjdGlvbjogdHJ1ZSxcclxuICBhcGlCYXNlVXJsOiAnJyxcclxuICBsb2dpbkVuZHBvaW50OiAnJyxcclxuICBhcGlTZWdtZW50OiAnYXBpL3YxLycsXHJcbn07XHJcbiJdfQ==

package/esm2022/lib/core/helpers/crypto-helper.service.mjs

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CryptoHelperService {
+    constructor() {
+        this.encoder = new TextEncoder();
+        this.decoder = new TextDecoder();
+        this.secretKey = ''; // Will be set by AuthService
+    }
+    setSecretKey(key) {
+        this.secretKey = key;
+    }
+    async getKey() {
+        const salt = this.encoder.encode('fixed_salt'); // Keep constant
+        const baseKey = await crypto.subtle.importKey('raw', this.encoder.encode(this.secretKey), 'PBKDF2', false, ['deriveKey']);
+        return crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            salt,
+            iterations: 100000,
+            hash: 'SHA-256',
+        }, baseKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+    }
+    async encrypt(value) {
+        if (!value)
+            return null;
+        const key = await this.getKey();
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, this.encoder.encode(value));
+        const merged = new Uint8Array(iv.length + encrypted.byteLength);
+        merged.set(iv, 0);
+        merged.set(new Uint8Array(encrypted), iv.length);
+        return btoa(String.fromCharCode(...merged));
+    }
+    async decrypt(value) {
+        if (!value)
+            return null;
+        const raw = Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+        const iv = raw.slice(0, 12);
+        const data = raw.slice(12);
+        const key = await this.getKey();
+        const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, data);
+        return this.decoder.decode(decrypted);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CryptoHelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CryptoHelperService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CryptoHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/http/http-stream.service.mjs

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import { HttpEventType, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import logger from '../utils/logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth/storage.service";
+import * as i2 from "@angular/common/http";
+export class HttpStreamService {
+    constructor(ngZone, tokenStorage, http) {
+        this.ngZone = ngZone;
+        this.tokenStorage = tokenStorage;
+        this.http = http;
+    }
+    /**
+     * Creates a POST-based HTTP streaming connection using fetch()
+     */
+    createHttpStream(url, body, headers) {
+        return new Observable((observer) => {
+            // Note: Authorization header is added automatically by AuthInterceptor
+            let requestHeaders = new HttpHeaders({
+                'content-type': 'application/json',
+                accept: 'text/event-stream',
+                'cache-control': 'no-cache',
+            });
+            if (headers) {
+                Object.keys(headers).forEach((key) => {
+                    requestHeaders = requestHeaders.set(key, headers[key]);
+                });
+            }
+            const req = this.http.request('POST', url, {
+                body,
+                headers: requestHeaders,
+                reportProgress: true,
+                observe: 'events',
+                responseType: 'text',
+            });
+            let lastLoaded = 0;
+            const sub = req.subscribe({
+                next: (event) => {
+                    if (event.type === HttpEventType.DownloadProgress) {
+                        // Process the new chunk of data
+                        const fullText = event.partialText;
+                        if (!fullText)
+                            return;
+                        const newText = fullText.slice(lastLoaded);
+                        lastLoaded = fullText.length;
+                        const lines = newText.split('\n');
+                        for (const line of lines) {
+                            if (line.trim() === '')
+                                continue;
+                            if (line.startsWith('data: ')) {
+                                const dataStr = line.substring(6).trim();
+                                if (dataStr === '[DONE]') {
+                                    this.ngZone.run(() => observer.complete());
+                                    return;
+                                }
+                                try {
+                                    const parsed = JSON.parse(dataStr);
+                                    this.ngZone.run(() => observer.next({
+                                        content: parsed.content ?? parsed.message ?? '',
+                                        type: parsed.type ?? 'chunk',
+                                        id: parsed.response_id ?? '',
+                                        created_at: parsed.created_at ?? '',
+                                        sources: parsed.sources ?? [],
+                                        error: parsed.error,
+                                    }));
+                                }
+                                catch (e) {
+                                    logger.warn('Failed to parse SSE data:', dataStr, e);
+                                }
+                            }
+                        }
+                    }
+                    else if (event.type === HttpEventType.Response) {
+                        this.ngZone.run(() => observer.complete());
+                    }
+                },
+                error: (err) => {
+                    this.ngZone.run(() => observer.error(err));
+                },
+                complete: () => {
+                    this.ngZone.run(() => observer.complete());
+                },
+            });
+            return () => sub.unsubscribe();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpStreamService, deps: [{ token: i0.NgZone }, { token: i1.StorageService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpStreamService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpStreamService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i1.StorageService }, { type: i2.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-stream.service.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/core/http/http-stream.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAU,MAAM,eAAe,CAAC;AACnD,OAAO,EAAc,aAAa,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAGlC,OAAO,MAAM,MAAM,yBAAyB,CAAC;;;;AAK7C,MAAM,OAAO,iBAAiB;IAC5B,YACU,MAAc,EACd,YAA4B,EAC5B,IAAgB;QAFhB,WAAM,GAAN,MAAM,CAAQ;QACd,iBAAY,GAAZ,YAAY,CAAgB;QAC5B,SAAI,GAAJ,IAAI,CAAY;IACvB,CAAC;IAEJ;;OAEG;IACH,gBAAgB,CACd,GAAW,EACX,IAAS,EACT,OAAgC;QAEhC,OAAO,IAAI,UAAU,CAAqB,CAAC,QAAQ,EAAE,EAAE;YACrD,uEAAuE;YACvE,IAAI,cAAc,GAAG,IAAI,WAAW,CAAC;gBACnC,cAAc,EAAE,kBAAkB;gBAClC,MAAM,EAAE,mBAAmB;gBAC3B,eAAe,EAAE,UAAU;aAC5B,CAAC,CAAC;YAEH,IAAI,OAAO,EAAE;gBACX,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;oBACnC,cAAc,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;gBACzD,CAAC,CAAC,CAAC;aACJ;YAED,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE;gBACzC,IAAI;gBACJ,OAAO,EAAE,cAAc;gBACvB,cAAc,EAAE,IAAI;gBACpB,OAAO,EAAE,QAAQ;gBACjB,YAAY,EAAE,MAAM;aACrB,CAAC,CAAC;YAEH,IAAI,UAAU,GAAG,CAAC,CAAC;YAEnB,MAAM,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC;gBACxB,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;oBACd,IAAI,KAAK,CAAC,IAAI,KAAK,aAAa,CAAC,gBAAgB,EAAE;wBACjD,gCAAgC;wBAChC,MAAM,QAAQ,GAAI,KAAa,CAAC,WAAW,CAAC;wBAC5C,IAAI,CAAC,QAAQ;4BAAE,OAAO;wBAEtB,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;wBAC3C,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC;wBAE7B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;wBAElC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;4BACxB,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;gCAAE,SAAS;4BAEjC,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;gCAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;gCAEzC,IAAI,OAAO,KAAK,QAAQ,EAAE;oCACxB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;oCAC3C,OAAO;iCACR;gCAED,IAAI;oCACF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;oCACnC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CACnB,QAAQ,CAAC,IAAI,CAAC;wCACZ,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,IAAI,EAAE;wCAC/C,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,OAAO;wCAC5B,EAAE,EAAE,MAAM,CAAC,WAAW,IAAI,EAAE;wCAC5B,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,EAAE;wCACnC,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,EAAE;wCAC7B,KAAK,EAAE,MAAM,CAAC,KAAK;qCACpB,CAAC,CACH,CAAC;iCACH;gCAAC,OAAO,CAAC,EAAE;oCACV,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;iCACtD;6BACF;yBACF;qBACF;yBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,aAAa,CAAC,QAAQ,EAAE;wBAChD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;qBAC5C;gBACH,CAAC;gBACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;oBACb,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC7C,CAAC;gBACD,QAAQ,EAAE,GAAG,EAAE;oBACb,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC7C,CAAC;aACF,CAAC,CAAC;YAEH,OAAO,GAAG,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;+GA7FU,iBAAiB;mHAAjB,iBAAiB,cAFhB,MAAM;;4FAEP,iBAAiB;kBAH7B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { HttpClient, HttpEventType, HttpHeaders } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { StorageService } from '../auth/storage.service';\r\nimport { ChatStreamResponse } from '../../app/chat/model/chat-stream-response.model';\r\nimport logger from '../utils/logger.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class HttpStreamService {\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private tokenStorage: StorageService,\r\n    private http: HttpClient,\r\n  ) {}\r\n\r\n  /**\r\n   * Creates a POST-based HTTP streaming connection using fetch()\r\n   */\r\n  createHttpStream(\r\n    url: string,\r\n    body: any,\r\n    headers?: Record<string, string>,\r\n  ): Observable<ChatStreamResponse> {\r\n    return new Observable<ChatStreamResponse>((observer) => {\r\n      // Note: Authorization header is added automatically by AuthInterceptor\r\n      let requestHeaders = new HttpHeaders({\r\n        'content-type': 'application/json',\r\n        accept: 'text/event-stream',\r\n        'cache-control': 'no-cache',\r\n      });\r\n\r\n      if (headers) {\r\n        Object.keys(headers).forEach((key) => {\r\n          requestHeaders = requestHeaders.set(key, headers[key]);\r\n        });\r\n      }\r\n\r\n      const req = this.http.request('POST', url, {\r\n        body,\r\n        headers: requestHeaders,\r\n        reportProgress: true,\r\n        observe: 'events',\r\n        responseType: 'text',\r\n      });\r\n\r\n      let lastLoaded = 0;\r\n\r\n      const sub = req.subscribe({\r\n        next: (event) => {\r\n          if (event.type === HttpEventType.DownloadProgress) {\r\n            // Process the new chunk of data\r\n            const fullText = (event as any).partialText;\r\n            if (!fullText) return;\r\n\r\n            const newText = fullText.slice(lastLoaded);\r\n            lastLoaded = fullText.length;\r\n\r\n            const lines = newText.split('\\n');\r\n\r\n            for (const line of lines) {\r\n              if (line.trim() === '') continue;\r\n\r\n              if (line.startsWith('data: ')) {\r\n                const dataStr = line.substring(6).trim();\r\n\r\n                if (dataStr === '[DONE]') {\r\n                  this.ngZone.run(() => observer.complete());\r\n                  return;\r\n                }\r\n\r\n                try {\r\n                  const parsed = JSON.parse(dataStr);\r\n                  this.ngZone.run(() =>\r\n                    observer.next({\r\n                      content: parsed.content ?? parsed.message ?? '',\r\n                      type: parsed.type ?? 'chunk',\r\n                      id: parsed.response_id ?? '',\r\n                      created_at: parsed.created_at ?? '',\r\n                      sources: parsed.sources ?? [],\r\n                      error: parsed.error,\r\n                    }),\r\n                  );\r\n                } catch (e) {\r\n                  logger.warn('Failed to parse SSE data:', dataStr, e);\r\n                }\r\n              }\r\n            }\r\n          } else if (event.type === HttpEventType.Response) {\r\n            this.ngZone.run(() => observer.complete());\r\n          }\r\n        },\r\n        error: (err) => {\r\n          this.ngZone.run(() => observer.error(err));\r\n        },\r\n        complete: () => {\r\n          this.ngZone.run(() => observer.complete());\r\n        },\r\n      });\r\n\r\n      return () => sub.unsubscribe();\r\n    });\r\n  }\r\n}\r\n"]}