valtech-components 4.0.219 → 4.0.221

package/esm2022/lib/components/organisms/chat-window/chat-window.component.mjs

@@ -0,0 +1,246 @@
+import { Component, Input, Output, EventEmitter, inject, computed, ViewChild, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonIcon, IonSpinner } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { chatbubblesOutline } from 'ionicons/icons';
+import { I18nService } from '../../../services/i18n';
+import { MessageBubbleComponent } from '../../molecules/message-bubble/message-bubble.component';
+import { ChatInputComponent } from '../../molecules/chat-input/chat-input.component';
+import { TypingIndicatorComponent } from '../../molecules/typing-indicator/typing-indicator.component';
+import * as i0 from "@angular/core";
+addIcons({ chatbubblesOutline });
+const CHAT_WINDOW_I18N = {
+    es: {
+        conversationClosed: 'Esta conversacion esta cerrada',
+        loading: 'Cargando mensajes...',
+        noMessages: 'No hay mensajes aun',
+    },
+    en: {
+        conversationClosed: 'This conversation is closed',
+        loading: 'Loading messages...',
+        noMessages: 'No messages yet',
+    },
+};
+/**
+ * val-chat-window
+ *
+ * Ventana de chat completa. Muestra la lista de mensajes agrupados por fecha,
+ * el indicador de escritura, el input de mensaje (solo si isOpen) y un banner
+ * cuando la conversacion esta cerrada. Auto-scroll al ultimo mensaje cuando
+ * llegan mensajes nuevos.
+ *
+ * @example
+ * <val-chat-window
+ *   [convId]="conv.id"
+ *   [messages]="messages()"
+ *   [currentUserId]="userId"
+ *   [isOpen]="conv.status === 'open'"
+ *   [typingUsers]="typingUsers()"
+ *   (sendMessage)="onSend($event)"
+ *   (reactionClick)="onReaction($event)"
+ * />
+ */
+export class ChatWindowComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.convId = '';
+        this.messages = [];
+        this.participants = [];
+        this.currentUserId = '';
+        this.isOpen = true;
+        this.typingUsers = [];
+        this.isLoading = false;
+        this.sendMessage = new EventEmitter();
+        this.loadMore = new EventEmitter();
+        this.reactionClick = new EventEmitter();
+        this.deleteMessage = new EventEmitter();
+        this.replyTo = new EventEmitter();
+        this.prevMessageCount = 0;
+        this.shouldScrollToBottom = false;
+        this.messageGroups = computed(() => {
+            const msgs = this.messages ?? [];
+            if (msgs.length === 0)
+                return [];
+            const groups = [];
+            let currentLabel = '';
+            let currentGroup = [];
+            for (const msg of msgs) {
+                const label = this.formatDateLabel(msg.createdAt);
+                if (label !== currentLabel) {
+                    if (currentGroup.length > 0) {
+                        groups.push({ dateLabel: currentLabel, messages: currentGroup });
+                    }
+                    currentLabel = label;
+                    currentGroup = [msg];
+                }
+                else {
+                    currentGroup.push(msg);
+                }
+            }
+            if (currentGroup.length > 0) {
+                groups.push({ dateLabel: currentLabel, messages: currentGroup });
+            }
+            return groups;
+        });
+        this.closedText = computed(() => {
+            this.i18n.lang();
+            return this.i18n.t('conversationClosed', 'ChatWindow');
+        });
+        this.loadingText = computed(() => {
+            this.i18n.lang();
+            return this.i18n.t('loading', 'ChatWindow');
+        });
+        this.i18n.registerDefaults('ChatWindow', CHAT_WINDOW_I18N);
+    }
+    ngOnChanges(changes) {
+        if (changes['messages']) {
+            const current = changes['messages'].currentValue ?? [];
+            if (current.length !== this.prevMessageCount) {
+                this.prevMessageCount = current.length;
+                this.shouldScrollToBottom = true;
+            }
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.shouldScrollToBottom) {
+            this.scrollToBottom();
+            this.shouldScrollToBottom = false;
+        }
+    }
+    onReactionClick(event) {
+        this.reactionClick.emit({ msgId: event.msgId, token: event.token });
+    }
+    onEditClick(_msgId) {
+        // Implementacion futura: emitir evento de edicion
+    }
+    onTyping() {
+        // El padre puede suscribirse al output typing si necesita propagar a Firestore
+    }
+    scrollToBottom() {
+        const el = this.messagesListRef?.nativeElement;
+        if (el) {
+            el.scrollTop = el.scrollHeight;
+        }
+    }
+    formatDateLabel(date) {
+        if (!date)
+            return '';
+        const d = date instanceof Date ? date : new Date(date);
+        const now = new Date();
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        const msgDay = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+        const diffMs = today.getTime() - msgDay.getTime();
+        const diffDays = Math.round(diffMs / 86400000);
+        if (diffDays === 0)
+            return this.i18n.t('today', '_global') || 'Hoy';
+        if (diffDays === 1)
+            return this.i18n.t('yesterday', '_global') || 'Ayer';
+        return d.toLocaleDateString([], { day: '2-digit', month: 'short', year: 'numeric' });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatWindowComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ChatWindowComponent, isStandalone: true, selector: "val-chat-window", inputs: { convId: "convId", messages: "messages", participants: "participants", currentUserId: "currentUserId", isOpen: "isOpen", typingUsers: "typingUsers", isLoading: "isLoading" }, outputs: { sendMessage: "sendMessage", loadMore: "loadMore", reactionClick: "reactionClick", deleteMessage: "deleteMessage", replyTo: "replyTo" }, viewQueries: [{ propertyName: "messagesListRef", first: true, predicate: ["messagesList"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div class="chat-window">
+      <div class="messages-list" #messagesList>
+        @if (isLoading) {
+          <div class="loading-state">
+            <ion-spinner name="dots"></ion-spinner>
+            <span>{{ loadingText() }}</span>
+          </div>
+        } @else {
+          @for (group of messageGroups(); track group.dateLabel) {
+            <div class="date-separator">
+              <div class="date-line"></div>
+              <span class="date-label">{{ group.dateLabel }}</span>
+              <div class="date-line"></div>
+            </div>
+            @for (msg of group.messages; track msg.msgId) {
+              <val-message-bubble
+                [props]="msg"
+                (reactionClick)="onReactionClick($event)"
+                (replyClick)="replyTo.emit($event.msgId)"
+                (deleteClick)="deleteMessage.emit($event.msgId)"
+                (editClick)="onEditClick($event.msgId)"
+              />
+            }
+          }
+        }
+      </div>
+
+      <val-typing-indicator [typingUsers]="typingUsers" />
+
+      @if (!isOpen) {
+        <div class="closed-banner">{{ closedText() }}</div>
+      } @else {
+        <val-chat-input [props]="{ disabled: isLoading }" (send)="sendMessage.emit($event)" (typing)="onTyping()" />
+      }
+    </div>
+  `, isInline: true, styles: [".chat-window{display:flex;flex-direction:column;height:100%;background:var(--ion-background-color, #f4f5f8);overflow:hidden}.messages-list{flex:1;overflow-y:auto;padding:12px 8px;scroll-behavior:smooth}.messages-list::-webkit-scrollbar{width:4px}.messages-list::-webkit-scrollbar-thumb{background:var(--ion-color-light-shade, #d7d8da);border-radius:2px}.date-separator{display:flex;align-items:center;gap:8px;margin:12px 0}.date-separator .date-line{flex:1;height:1px;background:var(--ion-border-color, rgba(0, 0, 0, .1))}.date-separator .date-label{font-size:.75rem;color:var(--ion-color-medium, #92949c);white-space:nowrap;padding:0 4px}.loading-state{display:flex;align-items:center;justify-content:center;padding:24px;color:var(--ion-color-medium, #92949c);font-size:.875rem;gap:8px}.closed-banner{padding:10px 16px;background:var(--ion-color-warning-tint, #fff9e6);border-top:1px solid var(--ion-color-warning, #ffc409);text-align:center;font-size:.875rem;color:var(--ion-color-warning-shade, #b29500)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: MessageBubbleComponent, selector: "val-message-bubble", inputs: ["props"], outputs: ["reactionClick", "replyClick", "deleteClick", "editClick"] }, { kind: "component", type: ChatInputComponent, selector: "val-chat-input", inputs: ["props"], outputs: ["send", "typing"] }, { kind: "component", type: TypingIndicatorComponent, selector: "val-typing-indicator", inputs: ["typingUsers"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatWindowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-chat-window', standalone: true, imports: [CommonModule, IonIcon, IonSpinner, MessageBubbleComponent, ChatInputComponent, TypingIndicatorComponent], template: `
+    <div class="chat-window">
+      <div class="messages-list" #messagesList>
+        @if (isLoading) {
+          <div class="loading-state">
+            <ion-spinner name="dots"></ion-spinner>
+            <span>{{ loadingText() }}</span>
+          </div>
+        } @else {
+          @for (group of messageGroups(); track group.dateLabel) {
+            <div class="date-separator">
+              <div class="date-line"></div>
+              <span class="date-label">{{ group.dateLabel }}</span>
+              <div class="date-line"></div>
+            </div>
+            @for (msg of group.messages; track msg.msgId) {
+              <val-message-bubble
+                [props]="msg"
+                (reactionClick)="onReactionClick($event)"
+                (replyClick)="replyTo.emit($event.msgId)"
+                (deleteClick)="deleteMessage.emit($event.msgId)"
+                (editClick)="onEditClick($event.msgId)"
+              />
+            }
+          }
+        }
+      </div>
+
+      <val-typing-indicator [typingUsers]="typingUsers" />
+
+      @if (!isOpen) {
+        <div class="closed-banner">{{ closedText() }}</div>
+      } @else {
+        <val-chat-input [props]="{ disabled: isLoading }" (send)="sendMessage.emit($event)" (typing)="onTyping()" />
+      }
+    </div>
+  `, styles: [".chat-window{display:flex;flex-direction:column;height:100%;background:var(--ion-background-color, #f4f5f8);overflow:hidden}.messages-list{flex:1;overflow-y:auto;padding:12px 8px;scroll-behavior:smooth}.messages-list::-webkit-scrollbar{width:4px}.messages-list::-webkit-scrollbar-thumb{background:var(--ion-color-light-shade, #d7d8da);border-radius:2px}.date-separator{display:flex;align-items:center;gap:8px;margin:12px 0}.date-separator .date-line{flex:1;height:1px;background:var(--ion-border-color, rgba(0, 0, 0, .1))}.date-separator .date-label{font-size:.75rem;color:var(--ion-color-medium, #92949c);white-space:nowrap;padding:0 4px}.loading-state{display:flex;align-items:center;justify-content:center;padding:24px;color:var(--ion-color-medium, #92949c);font-size:.875rem;gap:8px}.closed-banner{padding:10px 16px;background:var(--ion-color-warning-tint, #fff9e6);border-top:1px solid var(--ion-color-warning, #ffc409);text-align:center;font-size:.875rem;color:var(--ion-color-warning-shade, #b29500)}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { convId: [{
+                type: Input
+            }], messages: [{
+                type: Input
+            }], participants: [{
+                type: Input
+            }], currentUserId: [{
+                type: Input
+            }], isOpen: [{
+                type: Input
+            }], typingUsers: [{
+                type: Input
+            }], isLoading: [{
+                type: Input
+            }], sendMessage: [{
+                type: Output
+            }], loadMore: [{
+                type: Output
+            }], reactionClick: [{
+                type: Output
+            }], deleteMessage: [{
+                type: Output
+            }], replyTo: [{
+                type: Output
+            }], messagesListRef: [{
+                type: ViewChild,
+                args: ['messagesList']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat-window.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/chat-window/chat-window.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  inject,\n  computed,\n  signal,\n  OnChanges,\n  SimpleChanges,\n  ViewChild,\n  ElementRef,\n  AfterViewChecked,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { IonIcon, IonSpinner } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { chatbubblesOutline } from 'ionicons/icons';\nimport { I18nService } from '../../../services/i18n';\nimport { MessageBubbleComponent } from '../../molecules/message-bubble/message-bubble.component';\nimport { ChatInputComponent } from '../../molecules/chat-input/chat-input.component';\nimport { TypingIndicatorComponent } from '../../molecules/typing-indicator/typing-indicator.component';\nimport { MessageBubbleMetadata, MessageReactionClickEvent } from '../../molecules/message-bubble/types';\n\naddIcons({ chatbubblesOutline });\n\nconst CHAT_WINDOW_I18N = {\n  es: {\n    conversationClosed: 'Esta conversacion esta cerrada',\n    loading: 'Cargando mensajes...',\n    noMessages: 'No hay mensajes aun',\n  },\n  en: {\n    conversationClosed: 'This conversation is closed',\n    loading: 'Loading messages...',\n    noMessages: 'No messages yet',\n  },\n};\n\n/** Estructura interna para agrupar mensajes por fecha. */\ninterface MessageGroup {\n  dateLabel: string;\n  messages: MessageBubbleMetadata[];\n}\n\n/**\n * val-chat-window\n *\n * Ventana de chat completa. Muestra la lista de mensajes agrupados por fecha,\n * el indicador de escritura, el input de mensaje (solo si isOpen) y un banner\n * cuando la conversacion esta cerrada. Auto-scroll al ultimo mensaje cuando\n * llegan mensajes nuevos.\n *\n * @example\n * <val-chat-window\n *   [convId]=\"conv.id\"\n *   [messages]=\"messages()\"\n *   [currentUserId]=\"userId\"\n *   [isOpen]=\"conv.status === 'open'\"\n *   [typingUsers]=\"typingUsers()\"\n *   (sendMessage)=\"onSend($event)\"\n *   (reactionClick)=\"onReaction($event)\"\n * />\n */\n@Component({\n  selector: 'val-chat-window',\n  standalone: true,\n  imports: [CommonModule, IonIcon, IonSpinner, MessageBubbleComponent, ChatInputComponent, TypingIndicatorComponent],\n  template: `\n    <div class=\"chat-window\">\n      <div class=\"messages-list\" #messagesList>\n        @if (isLoading) {\n          <div class=\"loading-state\">\n            <ion-spinner name=\"dots\"></ion-spinner>\n            <span>{{ loadingText() }}</span>\n          </div>\n        } @else {\n          @for (group of messageGroups(); track group.dateLabel) {\n            <div class=\"date-separator\">\n              <div class=\"date-line\"></div>\n              <span class=\"date-label\">{{ group.dateLabel }}</span>\n              <div class=\"date-line\"></div>\n            </div>\n            @for (msg of group.messages; track msg.msgId) {\n              <val-message-bubble\n                [props]=\"msg\"\n                (reactionClick)=\"onReactionClick($event)\"\n                (replyClick)=\"replyTo.emit($event.msgId)\"\n                (deleteClick)=\"deleteMessage.emit($event.msgId)\"\n                (editClick)=\"onEditClick($event.msgId)\"\n              />\n            }\n          }\n        }\n      </div>\n\n      <val-typing-indicator [typingUsers]=\"typingUsers\" />\n\n      @if (!isOpen) {\n        <div class=\"closed-banner\">{{ closedText() }}</div>\n      } @else {\n        <val-chat-input [props]=\"{ disabled: isLoading }\" (send)=\"sendMessage.emit($event)\" (typing)=\"onTyping()\" />\n      }\n    </div>\n  `,\n  styleUrls: ['./chat-window.component.scss'],\n})\nexport class ChatWindowComponent implements OnChanges, AfterViewChecked {\n  protected i18n = inject(I18nService);\n\n  @Input() convId: string = '';\n  @Input() messages: MessageBubbleMetadata[] = [];\n  @Input() participants: string[] = [];\n  @Input() currentUserId: string = '';\n  @Input() isOpen: boolean = true;\n  @Input() typingUsers: string[] = [];\n  @Input() isLoading: boolean = false;\n\n  @Output() sendMessage = new EventEmitter<string>();\n  @Output() loadMore = new EventEmitter<void>();\n  @Output() reactionClick = new EventEmitter<{ msgId: string; token: string }>();\n  @Output() deleteMessage = new EventEmitter<string>();\n  @Output() replyTo = new EventEmitter<string>();\n\n  @ViewChild('messagesList') private messagesListRef?: ElementRef<HTMLDivElement>;\n\n  private prevMessageCount = 0;\n  private shouldScrollToBottom = false;\n\n  constructor() {\n    this.i18n.registerDefaults('ChatWindow', CHAT_WINDOW_I18N);\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['messages']) {\n      const current = (changes['messages'].currentValue as MessageBubbleMetadata[]) ?? [];\n      if (current.length !== this.prevMessageCount) {\n        this.prevMessageCount = current.length;\n        this.shouldScrollToBottom = true;\n      }\n    }\n  }\n\n  ngAfterViewChecked(): void {\n    if (this.shouldScrollToBottom) {\n      this.scrollToBottom();\n      this.shouldScrollToBottom = false;\n    }\n  }\n\n  protected messageGroups = computed((): MessageGroup[] => {\n    const msgs = this.messages ?? [];\n    if (msgs.length === 0) return [];\n\n    const groups: MessageGroup[] = [];\n    let currentLabel = '';\n    let currentGroup: MessageBubbleMetadata[] = [];\n\n    for (const msg of msgs) {\n      const label = this.formatDateLabel(msg.createdAt);\n      if (label !== currentLabel) {\n        if (currentGroup.length > 0) {\n          groups.push({ dateLabel: currentLabel, messages: currentGroup });\n        }\n        currentLabel = label;\n        currentGroup = [msg];\n      } else {\n        currentGroup.push(msg);\n      }\n    }\n\n    if (currentGroup.length > 0) {\n      groups.push({ dateLabel: currentLabel, messages: currentGroup });\n    }\n\n    return groups;\n  });\n\n  protected closedText = computed(() => {\n    this.i18n.lang();\n    return this.i18n.t('conversationClosed', 'ChatWindow');\n  });\n\n  protected loadingText = computed(() => {\n    this.i18n.lang();\n    return this.i18n.t('loading', 'ChatWindow');\n  });\n\n  protected onReactionClick(event: MessageReactionClickEvent): void {\n    this.reactionClick.emit({ msgId: event.msgId, token: event.token });\n  }\n\n  protected onEditClick(_msgId: string): void {\n    // Implementacion futura: emitir evento de edicion\n  }\n\n  protected onTyping(): void {\n    // El padre puede suscribirse al output typing si necesita propagar a Firestore\n  }\n\n  private scrollToBottom(): void {\n    const el = this.messagesListRef?.nativeElement;\n    if (el) {\n      el.scrollTop = el.scrollHeight;\n    }\n  }\n\n  private formatDateLabel(date: Date): string {\n    if (!date) return '';\n    const d = date instanceof Date ? date : new Date(date);\n    const now = new Date();\n    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());\n    const msgDay = new Date(d.getFullYear(), d.getMonth(), d.getDate());\n    const diffMs = today.getTime() - msgDay.getTime();\n    const diffDays = Math.round(diffMs / 86400000);\n\n    if (diffDays === 0) return this.i18n.t('today', '_global') || 'Hoy';\n    if (diffDays === 1) return this.i18n.t('yesterday', '_global') || 'Ayer';\n    return d.toLocaleDateString([], { day: '2-digit', month: 'short', year: 'numeric' });\n  }\n}\n"]}

package/esm2022/lib/components/organisms/chat-window/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvb3JnYW5pc21zL2NoYXQtd2luZG93L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNZXNzYWdlQnViYmxlTWV0YWRhdGEgfSBmcm9tICcuLi8uLi9tb2xlY3VsZXMvbWVzc2FnZS1idWJibGUvdHlwZXMnO1xuXG4vKipcbiAqIENvbmZpZ3VyYWNpb24gZGVsIGNvbXBvbmVudGUgZGUgdmVudGFuYSBkZSBjaGF0LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIENoYXRXaW5kb3dNZXRhZGF0YSB7XG4gIC8qKiBJRCBkZSBsYSBjb252ZXJzYWNpb24uICovXG4gIGNvbnZJZDogc3RyaW5nO1xuICAvKiogTGlzdGEgZGUgbWVuc2FqZXMgYSBtb3N0cmFyLiAqL1xuICBtZXNzYWdlcz86IE1lc3NhZ2VCdWJibGVNZXRhZGF0YVtdO1xuICAvKiogSURzIG8gbm9tYnJlcyBkZSBwYXJ0aWNpcGFudGVzLiAqL1xuICBwYXJ0aWNpcGFudHM/OiBzdHJpbmdbXTtcbiAgLyoqIElEIGRlbCB1c3VhcmlvIGFjdHVhbCAocGFyYSBtYXJjYXIgbWVuc2FqZXMgcHJvcGlvcykuICovXG4gIGN1cnJlbnRVc2VySWQ/OiBzdHJpbmc7XG4gIC8qKiBTaSBsYSBjb252ZXJzYWNpb24gZXN0YSBhYmllcnRhIHBhcmEgZW52aWFyIG1lbnNhamVzLiAqL1xuICBpc09wZW4/OiBib29sZWFuO1xuICAvKiogVXN1YXJpb3MgcXVlIGVzdGFuIGVzY3JpYmllbmRvIGVuIGVzdGUgbW9tZW50by4gKi9cbiAgdHlwaW5nVXNlcnM/OiBzdHJpbmdbXTtcbiAgLyoqIFNpIGVzdGEgY2FyZ2FuZG8gbWVuc2FqZXMuICovXG4gIGlzTG9hZGluZz86IGJvb2xlYW47XG59XG5cbi8qKlxuICogRXZlbnRvIGVtaXRpZG8gYWwgZW52aWFyIHVuIG1lbnNhamUgZGVzZGUgbGEgdmVudGFuYSBkZSBjaGF0LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIENoYXRXaW5kb3dTZW5kRXZlbnQge1xuICAvKiogQ3VlcnBvIGRlbCBtZW5zYWplLiAqL1xuICBib2R5OiBzdHJpbmc7XG59XG5cbi8qKlxuICogRXZlbnRvIGVtaXRpZG8gYWwgaGFjZXIgY2xpYyBlbiB1bmEgcmVhY2Npb24gZGUgdW4gbWVuc2FqZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDaGF0V2luZG93UmVhY3Rpb25FdmVudCB7XG4gIC8qKiBJRCBkZWwgbWVuc2FqZS4gKi9cbiAgbXNnSWQ6IHN0cmluZztcbiAgLyoqIFRva2VuIGRlIGxhIHJlYWNjaW9uLiAqL1xuICB0b2tlbjogc3RyaW5nO1xufVxuIl19

package/esm2022/lib/components/organisms/thread-panel/thread-panel.component.mjs

@@ -0,0 +1,211 @@
+import { Component, Input, inject, signal, computed } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonSpinner } from '@ionic/angular/standalone';
+import { firstValueFrom } from 'rxjs';
+import { I18nService } from '../../../services/i18n';
+import { ConversationService } from '../../../services/chat/conversation.service';
+import { VALTECH_CHAT_CONFIG } from '../../../services/chat/config';
+import { AuthService } from '../../../services/auth/auth.service';
+import { ChatWindowComponent } from '../chat-window/chat-window.component';
+import * as i0 from "@angular/core";
+const THREAD_PANEL_I18N = {
+    es: {
+        loading: 'Cargando conversacion...',
+        thread: 'Hilo',
+    },
+    en: {
+        loading: 'Loading conversation...',
+        thread: 'Thread',
+    },
+};
+/**
+ * val-thread-panel
+ *
+ * Panel de hilo de conversacion asociado a una entidad (post, request, etc.).
+ * Internamente usa ConversationService.getOrCreateForEntity() para inicializar
+ * la conversacion y luego watchMessages() para escuchar en tiempo real.
+ * Renderiza val-chat-window con los mensajes ya mapeados.
+ *
+ * Requiere provideValtechChat() y provideValtechFirebase() en main.ts.
+ *
+ * @example
+ * <val-thread-panel
+ *   entityType="post"
+ *   entityId="post-abc123"
+ *   currentUserId="user-xyz"
+ *   title="Comentarios"
+ * />
+ */
+export class ThreadPanelComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.conversationSvc = inject(ConversationService, { optional: true });
+        this.chatConfig = inject(VALTECH_CHAT_CONFIG, { optional: true });
+        this.auth = inject(AuthService, { optional: true });
+        this.entityType = '';
+        this.entityId = '';
+        this.currentUserId = '';
+        this.loading = signal(true);
+        this.conv = signal(null);
+        this.messages = signal([]);
+        this.typingUsers = signal([]);
+        this.isConvOpen = computed(() => this.conv()?.status === 'open');
+        this.loadingText = computed(() => {
+            this.i18n.lang();
+            return this.i18n.t('loading', 'ThreadPanel');
+        });
+        this.bubbleMessages = computed(() => {
+            const uid = this.currentUserId || this.auth?.user()?.userId || '';
+            return this.messages().map(msg => ({
+                msgId: msg.id,
+                senderId: msg.senderId,
+                senderName: msg.senderName,
+                senderAvatar: msg.senderAvatar,
+                body: msg.body,
+                type: msg.type,
+                createdAt: msg.createdAt,
+                isMine: msg.senderId === uid,
+                isDeleted: msg.isDeleted,
+                isEdited: msg.isEdited,
+                replyTo: msg.replyTo,
+                attachments: msg.attachments,
+                reactions: msg.reactions,
+                status: msg.status,
+            }));
+        });
+        this.i18n.registerDefaults('ThreadPanel', THREAD_PANEL_I18N);
+    }
+    async ngOnInit() {
+        if (!this.conversationSvc || !this.entityType || !this.entityId) {
+            this.loading.set(false);
+            return;
+        }
+        try {
+            const conversation = await firstValueFrom(this.conversationSvc.getOrCreateForEntity(this.entityType, this.entityId));
+            this.conv.set(conversation);
+            const orgId = this.getOrgId();
+            const appId = this.chatConfig?.appId ?? '';
+            if (orgId && appId) {
+                this.msgSub = this.conversationSvc
+                    .watchMessages(conversation.id, orgId, appId)
+                    .subscribe(msgs => this.messages.set(msgs));
+                this.typingSub = this.conversationSvc
+                    .watchTyping(conversation.id, orgId, appId)
+                    .subscribe(users => this.typingUsers.set(users));
+            }
+        }
+        catch (err) {
+            console.error('[ThreadPanel] Error al inicializar conversacion:', err);
+        }
+        finally {
+            this.loading.set(false);
+        }
+    }
+    ngOnDestroy() {
+        this.msgSub?.unsubscribe();
+        this.typingSub?.unsubscribe();
+        const conv = this.conv();
+        const orgId = this.getOrgId();
+        const appId = this.chatConfig?.appId ?? '';
+        if (conv && orgId && appId && this.conversationSvc) {
+            this.conversationSvc.stopTyping(conv.id, orgId, appId);
+        }
+    }
+    onSend(body) {
+        const conv = this.conv();
+        if (!conv || !this.conversationSvc)
+            return;
+        this.conversationSvc.sendMessage(conv.id, body).subscribe();
+    }
+    onReactionClick(event) {
+        // Reacciones se implementan a nivel de app consumer
+        console.debug('[ThreadPanel] reactionClick', event);
+    }
+    onDeleteMessage(msgId) {
+        const conv = this.conv();
+        if (!conv || !this.conversationSvc)
+            return;
+        this.conversationSvc.deleteMessage(conv.id, msgId).subscribe();
+    }
+    onReplyTo(_msgId) {
+        // Implementacion futura: seleccionar mensaje de respuesta
+    }
+    getOrgId() {
+        return this.auth?.user()?.activeOrg ?? '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThreadPanelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ThreadPanelComponent, isStandalone: true, selector: "val-thread-panel", inputs: { entityType: "entityType", entityId: "entityId", currentUserId: "currentUserId", title: "title" }, ngImport: i0, template: `
+    <div class="thread-panel">
+      @if (title) {
+        <div class="thread-header">
+          <p class="thread-title">{{ title }}</p>
+        </div>
+      }
+
+      @if (loading()) {
+        <div class="thread-loading">
+          <ion-spinner name="dots"></ion-spinner>
+          <span>{{ loadingText() }}</span>
+        </div>
+      } @else {
+        <div class="thread-chat">
+          <val-chat-window
+            [convId]="conv()?.id ?? ''"
+            [messages]="bubbleMessages()"
+            [currentUserId]="currentUserId"
+            [isOpen]="isConvOpen()"
+            [typingUsers]="typingUsers()"
+            [isLoading]="false"
+            (sendMessage)="onSend($event)"
+            (reactionClick)="onReactionClick($event)"
+            (deleteMessage)="onDeleteMessage($event)"
+            (replyTo)="onReplyTo($event)"
+          />
+        </div>
+      }
+    </div>
+  `, isInline: true, styles: [".thread-panel{display:flex;flex-direction:column;height:100%;background:var(--ion-background-color, #f4f5f8)}.thread-header{padding:12px 16px;border-bottom:1px solid var(--ion-border-color, rgba(0, 0, 0, .1));background:var(--ion-card-background, var(--ion-background-color, #fff))}.thread-header .thread-title{font-size:1rem;font-weight:600;color:var(--ion-text-color, #000);margin:0}.thread-loading{display:flex;align-items:center;justify-content:center;flex:1;gap:10px;color:var(--ion-color-medium, #92949c);font-size:.875rem}.thread-chat{flex:1;overflow:hidden;display:flex;flex-direction:column}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: ChatWindowComponent, selector: "val-chat-window", inputs: ["convId", "messages", "participants", "currentUserId", "isOpen", "typingUsers", "isLoading"], outputs: ["sendMessage", "loadMore", "reactionClick", "deleteMessage", "replyTo"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThreadPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-thread-panel', standalone: true, imports: [CommonModule, IonSpinner, ChatWindowComponent], template: `
+    <div class="thread-panel">
+      @if (title) {
+        <div class="thread-header">
+          <p class="thread-title">{{ title }}</p>
+        </div>
+      }
+
+      @if (loading()) {
+        <div class="thread-loading">
+          <ion-spinner name="dots"></ion-spinner>
+          <span>{{ loadingText() }}</span>
+        </div>
+      } @else {
+        <div class="thread-chat">
+          <val-chat-window
+            [convId]="conv()?.id ?? ''"
+            [messages]="bubbleMessages()"
+            [currentUserId]="currentUserId"
+            [isOpen]="isConvOpen()"
+            [typingUsers]="typingUsers()"
+            [isLoading]="false"
+            (sendMessage)="onSend($event)"
+            (reactionClick)="onReactionClick($event)"
+            (deleteMessage)="onDeleteMessage($event)"
+            (replyTo)="onReplyTo($event)"
+          />
+        </div>
+      }
+    </div>
+  `, styles: [".thread-panel{display:flex;flex-direction:column;height:100%;background:var(--ion-background-color, #f4f5f8)}.thread-header{padding:12px 16px;border-bottom:1px solid var(--ion-border-color, rgba(0, 0, 0, .1));background:var(--ion-card-background, var(--ion-background-color, #fff))}.thread-header .thread-title{font-size:1rem;font-weight:600;color:var(--ion-text-color, #000);margin:0}.thread-loading{display:flex;align-items:center;justify-content:center;flex:1;gap:10px;color:var(--ion-color-medium, #92949c);font-size:.875rem}.thread-chat{flex:1;overflow:hidden;display:flex;flex-direction:column}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { entityType: [{
+                type: Input
+            }], entityId: [{
+                type: Input
+            }], currentUserId: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"thread-panel.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/thread-panel/thread-panel.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, OnDestroy, inject, signal, computed } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { IonSpinner } from '@ionic/angular/standalone';\nimport { Subscription, firstValueFrom } from 'rxjs';\nimport { I18nService } from '../../../services/i18n';\nimport { ConversationService } from '../../../services/chat/conversation.service';\nimport { VALTECH_CHAT_CONFIG } from '../../../services/chat/config';\nimport { AuthService } from '../../../services/auth/auth.service';\nimport { Conversation, Message } from '../../../services/chat/types';\nimport { MessageBubbleMetadata } from '../../molecules/message-bubble/types';\nimport { ChatWindowComponent } from '../chat-window/chat-window.component';\n\nconst THREAD_PANEL_I18N = {\n  es: {\n    loading: 'Cargando conversacion...',\n    thread: 'Hilo',\n  },\n  en: {\n    loading: 'Loading conversation...',\n    thread: 'Thread',\n  },\n};\n\n/**\n * val-thread-panel\n *\n * Panel de hilo de conversacion asociado a una entidad (post, request, etc.).\n * Internamente usa ConversationService.getOrCreateForEntity() para inicializar\n * la conversacion y luego watchMessages() para escuchar en tiempo real.\n * Renderiza val-chat-window con los mensajes ya mapeados.\n *\n * Requiere provideValtechChat() y provideValtechFirebase() en main.ts.\n *\n * @example\n * <val-thread-panel\n *   entityType=\"post\"\n *   entityId=\"post-abc123\"\n *   currentUserId=\"user-xyz\"\n *   title=\"Comentarios\"\n * />\n */\n@Component({\n  selector: 'val-thread-panel',\n  standalone: true,\n  imports: [CommonModule, IonSpinner, ChatWindowComponent],\n  template: `\n    <div class=\"thread-panel\">\n      @if (title) {\n        <div class=\"thread-header\">\n          <p class=\"thread-title\">{{ title }}</p>\n        </div>\n      }\n\n      @if (loading()) {\n        <div class=\"thread-loading\">\n          <ion-spinner name=\"dots\"></ion-spinner>\n          <span>{{ loadingText() }}</span>\n        </div>\n      } @else {\n        <div class=\"thread-chat\">\n          <val-chat-window\n            [convId]=\"conv()?.id ?? ''\"\n            [messages]=\"bubbleMessages()\"\n            [currentUserId]=\"currentUserId\"\n            [isOpen]=\"isConvOpen()\"\n            [typingUsers]=\"typingUsers()\"\n            [isLoading]=\"false\"\n            (sendMessage)=\"onSend($event)\"\n            (reactionClick)=\"onReactionClick($event)\"\n            (deleteMessage)=\"onDeleteMessage($event)\"\n            (replyTo)=\"onReplyTo($event)\"\n          />\n        </div>\n      }\n    </div>\n  `,\n  styleUrls: ['./thread-panel.component.scss'],\n})\nexport class ThreadPanelComponent implements OnInit, OnDestroy {\n  protected i18n = inject(I18nService);\n  private conversationSvc = inject(ConversationService, { optional: true });\n  private chatConfig = inject(VALTECH_CHAT_CONFIG, { optional: true });\n  private auth = inject(AuthService, { optional: true });\n\n  @Input() entityType: string = '';\n  @Input() entityId: string = '';\n  @Input() currentUserId: string = '';\n  @Input() title?: string;\n\n  protected loading = signal(true);\n  protected conv = signal<Conversation | null>(null);\n  protected messages = signal<Message[]>([]);\n  protected typingUsers = signal<string[]>([]);\n\n  private msgSub?: Subscription;\n  private typingSub?: Subscription;\n\n  constructor() {\n    this.i18n.registerDefaults('ThreadPanel', THREAD_PANEL_I18N);\n  }\n\n  async ngOnInit(): Promise<void> {\n    if (!this.conversationSvc || !this.entityType || !this.entityId) {\n      this.loading.set(false);\n      return;\n    }\n\n    try {\n      const conversation = await firstValueFrom(\n        this.conversationSvc.getOrCreateForEntity(this.entityType, this.entityId)\n      );\n      this.conv.set(conversation);\n\n      const orgId = this.getOrgId();\n      const appId = this.chatConfig?.appId ?? '';\n\n      if (orgId && appId) {\n        this.msgSub = this.conversationSvc\n          .watchMessages(conversation.id, orgId, appId)\n          .subscribe(msgs => this.messages.set(msgs));\n\n        this.typingSub = this.conversationSvc\n          .watchTyping(conversation.id, orgId, appId)\n          .subscribe(users => this.typingUsers.set(users));\n      }\n    } catch (err) {\n      console.error('[ThreadPanel] Error al inicializar conversacion:', err);\n    } finally {\n      this.loading.set(false);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.msgSub?.unsubscribe();\n    this.typingSub?.unsubscribe();\n\n    const conv = this.conv();\n    const orgId = this.getOrgId();\n    const appId = this.chatConfig?.appId ?? '';\n    if (conv && orgId && appId && this.conversationSvc) {\n      this.conversationSvc.stopTyping(conv.id, orgId, appId);\n    }\n  }\n\n  protected isConvOpen = computed(() => this.conv()?.status === 'open');\n\n  protected loadingText = computed(() => {\n    this.i18n.lang();\n    return this.i18n.t('loading', 'ThreadPanel');\n  });\n\n  protected bubbleMessages = computed((): MessageBubbleMetadata[] => {\n    const uid = this.currentUserId || this.auth?.user()?.userId || '';\n    return this.messages().map(msg => ({\n      msgId: msg.id,\n      senderId: msg.senderId,\n      senderName: msg.senderName,\n      senderAvatar: msg.senderAvatar,\n      body: msg.body,\n      type: msg.type,\n      createdAt: msg.createdAt,\n      isMine: msg.senderId === uid,\n      isDeleted: msg.isDeleted,\n      isEdited: msg.isEdited,\n      replyTo: msg.replyTo,\n      attachments: msg.attachments,\n      reactions: msg.reactions,\n      status: msg.status,\n    }));\n  });\n\n  protected onSend(body: string): void {\n    const conv = this.conv();\n    if (!conv || !this.conversationSvc) return;\n    this.conversationSvc.sendMessage(conv.id, body).subscribe();\n  }\n\n  protected onReactionClick(event: { msgId: string; token: string }): void {\n    // Reacciones se implementan a nivel de app consumer\n    console.debug('[ThreadPanel] reactionClick', event);\n  }\n\n  protected onDeleteMessage(msgId: string): void {\n    const conv = this.conv();\n    if (!conv || !this.conversationSvc) return;\n    this.conversationSvc.deleteMessage(conv.id, msgId).subscribe();\n  }\n\n  protected onReplyTo(_msgId: string): void {\n    // Implementacion futura: seleccionar mensaje de respuesta\n  }\n\n  private getOrgId(): string {\n    return this.auth?.user()?.activeOrg ?? '';\n  }\n}\n"]}

package/esm2022/lib/services/chat/config.mjs

@@ -0,0 +1,35 @@
+import { InjectionToken, makeEnvironmentProviders } from '@angular/core';
+/**
+ * Token de inyeccion para la configuracion del Chat.
+ */
+export const VALTECH_CHAT_CONFIG = new InjectionToken('ValtechChatConfig');
+/**
+ * Configuracion por defecto del Chat.
+ */
+export const DEFAULT_CHAT_CONFIG = {
+    chatPrefix: '/v2/chat',
+};
+/**
+ * Provee el servicio de Chat a la aplicacion Angular.
+ *
+ * @example
+ * // main.ts
+ * import { provideValtechChat } from 'valtech-components';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechChat({
+ *       apiUrl: environment.apiUrl,
+ *       appId: 'showcase',
+ *     }),
+ *   ],
+ * });
+ */
+export function provideValtechChat(config) {
+    const mergedConfig = {
+        ...DEFAULT_CHAT_CONFIG,
+        ...config,
+    };
+    return makeEnvironmentProviders([{ provide: VALTECH_CHAT_CONFIG, useValue: mergedConfig }]);
+}
+//# sourceMappingURL=data:application/json;base64,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