valtech-components 2.0.404 → 2.0.406

package/esm2022/lib/components/organisms/comment-section/comment-section.component.mjs

@@ -0,0 +1,578 @@
+import { Component, Input, Output, EventEmitter, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { IonIcon, IonButton, IonBadge, IonTextarea, IonItem, IonSelect, IonSelectOption, IonSpinner, IonInfiniteScroll, IonInfiniteScrollContent, } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { chatbubblesOutline, filterOutline, sendOutline, chatbubbleEllipsesOutline, swapVerticalOutline, } from 'ionicons/icons';
+import { CommentComponent } from '../../molecules/comment/comment.component';
+import { AvatarComponent } from '../../atoms/avatar/avatar.component';
+import { SkeletonComponent } from '../../atoms/skeleton/skeleton.component';
+import { LangService } from '../../../services/lang-provider/lang-provider.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+addIcons({
+    chatbubblesOutline,
+    filterOutline,
+    sendOutline,
+    chatbubbleEllipsesOutline,
+    swapVerticalOutline,
+});
+/**
+ * val-comment-section
+ *
+ * An organism component that provides a complete comment section with:
+ * - Header with title and count
+ * - Sort/filter options
+ * - New comment input
+ * - Comments list with val-comment
+ * - Load more pagination
+ * - Empty state
+ *
+ * @example Basic usage
+ * <val-comment-section [props]="{
+ *   title: 'Comments',
+ *   count: 42,
+ *   comments: commentsArray,
+ *   showInput: true
+ * }"></val-comment-section>
+ *
+ * @example With sorting
+ * <val-comment-section [props]="{
+ *   title: 'Reviews',
+ *   count: 128,
+ *   comments: reviews,
+ *   sortOptions: [
+ *     { token: 'newest', label: 'Newest first' },
+ *     { token: 'oldest', label: 'Oldest first' },
+ *     { token: 'popular', label: 'Most popular' }
+ *   ],
+ *   selectedSort: 'newest'
+ * }" (sortChange)="onSort($event)"></val-comment-section>
+ *
+ * @input props: CommentSectionMetadata - Configuration for the section
+ * @output sortChange - Sort option changed
+ * @output commentSubmit - New comment submitted
+ * @output loadMore - Load more clicked
+ * @output authorClick - Comment author clicked (bubbled from val-comment)
+ * @output reactionClick - Reaction clicked (bubbled)
+ * @output actionClick - Action clicked (bubbled)
+ * @output menuItemClick - Menu item clicked (bubbled)
+ * @output commentLoadMore - Load more replies clicked (bubbled)
+ * @output collapseToggle - Comment collapse toggled (bubbled)
+ */
+export class CommentSectionComponent {
+    constructor() {
+        // Section events
+        this.sortChange = new EventEmitter();
+        this.commentSubmit = new EventEmitter();
+        this.loadMore = new EventEmitter();
+        // Bubbled events from val-comment
+        this.authorClick = new EventEmitter();
+        this.reactionClick = new EventEmitter();
+        this.actionClick = new EventEmitter();
+        this.menuItemClick = new EventEmitter();
+        this.commentLoadMore = new EventEmitter();
+        this.collapseToggle = new EventEmitter();
+        // Reply state
+        this.replyStart = new EventEmitter();
+        this.newCommentText = '';
+        this.replyingTo = null;
+        this.displayTitle = '';
+        this.displayLoadMoreLabel = '';
+        this.langSubscription = null;
+        this.langService = inject(LangService);
+        this.infiniteScrollEvent = null;
+    }
+    ngOnInit() {
+        this.updateDisplayTexts();
+        if (this.hasReactiveContent()) {
+            this.langSubscription = this.langService.currentLang$.subscribe(() => {
+                this.updateDisplayTexts();
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.langSubscription?.unsubscribe();
+    }
+    hasReactiveContent() {
+        return !!((this.props.titleContentKey && this.props.contentClass) ||
+            (this.props.loadMoreContentKey && this.props.contentClass));
+    }
+    updateDisplayTexts() {
+        // Title
+        if (this.props.titleContentKey && this.props.contentClass) {
+            this.displayTitle = this.langService.getText(this.props.contentClass, this.props.titleContentKey, this.props.titleContentFallback || this.props.title || 'Comments');
+        }
+        else {
+            this.displayTitle = this.props.title || 'Comments';
+        }
+        // Load more label
+        if (this.props.loadMoreContentKey && this.props.contentClass) {
+            this.displayLoadMoreLabel = this.langService.getText(this.props.contentClass, this.props.loadMoreContentKey, this.props.loadMoreLabel || 'Load more comments');
+        }
+        else {
+            this.displayLoadMoreLabel = this.props.loadMoreLabel || 'Load more comments';
+        }
+    }
+    formatCount(count) {
+        if (count >= 1000000) {
+            return (count / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
+        }
+        if (count >= 1000) {
+            return (count / 1000).toFixed(1).replace(/\.0$/, '') + 'K';
+        }
+        return count.toString();
+    }
+    getSortOptionLabel(option) {
+        if (option.contentKey && option.contentClass) {
+            return this.langService.getText(option.contentClass, option.contentKey, option.contentFallback || option.label);
+        }
+        return option.label;
+    }
+    getInputPlaceholder() {
+        const config = this.props.inputConfig;
+        if (config?.placeholderContentKey && config?.contentClass) {
+            return this.langService.getText(config.contentClass, config.placeholderContentKey, config.placeholder || 'Write a comment...');
+        }
+        return config?.placeholder || 'Write a comment...';
+    }
+    getSubmitLabel() {
+        const config = this.props.inputConfig;
+        if (config?.submitLabelContentKey && config?.contentClass) {
+            return this.langService.getText(config.contentClass, config.submitLabelContentKey, config.submitLabel || 'Post');
+        }
+        return config?.submitLabel || 'Post';
+    }
+    getEmptyTitle() {
+        const empty = this.props.emptyState;
+        if (empty?.titleContentKey && empty?.contentClass) {
+            return this.langService.getText(empty.contentClass, empty.titleContentKey, empty.title || 'No comments yet');
+        }
+        return empty?.title || 'No comments yet';
+    }
+    getEmptyMessage() {
+        const empty = this.props.emptyState;
+        if (empty?.messageContentKey && empty?.contentClass) {
+            return this.langService.getText(empty.contentClass, empty.messageContentKey, empty.message || 'Be the first to share your thoughts!');
+        }
+        return empty?.message || 'Be the first to share your thoughts!';
+    }
+    getSkeletonArray() {
+        const count = this.props.skeletonCount || 3;
+        return Array(count).fill(0).map((_, i) => i);
+    }
+    canSubmit() {
+        const minLength = this.props.inputConfig?.minLength || 1;
+        return (this.newCommentText.trim().length >= minLength &&
+            !this.props.loading &&
+            !this.props.inputConfig?.disabled);
+    }
+    isNearLimit() {
+        const maxLength = this.props.inputConfig?.maxLength || 2000;
+        return this.newCommentText.length > maxLength * 0.9;
+    }
+    onSortChange(event) {
+        const selectedToken = event.detail.value;
+        const option = this.props.sortOptions?.find((o) => o.token === selectedToken);
+        if (option) {
+            this.sortChange.emit({
+                option,
+                previousSort: this.props.selectedSort,
+            });
+        }
+    }
+    onSubmitComment() {
+        if (!this.canSubmit())
+            return;
+        this.commentSubmit.emit({
+            content: this.newCommentText.trim(),
+            parentToken: this.replyingTo || undefined,
+            sectionToken: this.props.token,
+        });
+        this.newCommentText = '';
+        this.replyingTo = null;
+    }
+    onCommentAction(event) {
+        // Check if it's a reply action
+        if (event.action.token === 'reply') {
+            this.replyingTo = event.commentToken;
+            this.replyStart.emit({ commentToken: event.commentToken });
+        }
+        this.actionClick.emit(event);
+    }
+    onLoadMore() {
+        this.loadMore.emit({
+            sectionToken: this.props.token,
+            currentCount: this.props.comments?.length || 0,
+        });
+    }
+    onInfiniteScroll(event) {
+        this.loadMore.emit({
+            sectionToken: this.props.token,
+            currentCount: this.props.comments?.length || 0,
+        });
+        // The parent component should call completeInfiniteScroll() when done loading
+        // Store reference to complete the infinite scroll
+        this.infiniteScrollEvent = event;
+    }
+    // Call this method from parent after loading more comments
+    completeInfiniteScroll() {
+        if (this.infiniteScrollEvent) {
+            this.infiniteScrollEvent.target.complete();
+            this.infiniteScrollEvent = null;
+        }
+    }
+    // Method to programmatically start a reply
+    startReply(commentToken) {
+        this.replyingTo = commentToken;
+    }
+    // Method to cancel reply
+    cancelReply() {
+        this.replyingTo = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommentSectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: CommentSectionComponent, isStandalone: true, selector: "val-comment-section", inputs: { props: "props" }, outputs: { sortChange: "sortChange", commentSubmit: "commentSubmit", loadMore: "loadMore", authorClick: "authorClick", reactionClick: "reactionClick", actionClick: "actionClick", menuItemClick: "menuItemClick", commentLoadMore: "commentLoadMore", collapseToggle: "collapseToggle", replyStart: "replyStart" }, ngImport: i0, template: `
+    <div class="comment-section" [class.loading]="props.loading">
+      <!-- Header -->
+      <div class="section-header">
+        <div class="header-title">
+          <ion-icon name="chatbubbles-outline" class="title-icon"></ion-icon>
+          <h3 class="title">{{ displayTitle }}</h3>
+          @if (props.showCount !== false && props.count !== undefined) {
+            <ion-badge color="medium" class="count-badge">
+              {{ formatCount(props.count) }}
+            </ion-badge>
+          }
+        </div>
+
+        @if (props.sortOptions && props.sortOptions.length > 0) {
+          <div class="header-actions">
+            <ion-item lines="none" class="sort-select-item">
+              <ion-icon name="swap-vertical-outline" slot="start" class="sort-icon"></ion-icon>
+              <ion-select
+                [value]="props.selectedSort"
+                [placeholder]="props.sortLabel || 'Sort by'"
+                interface="popover"
+                (ionChange)="onSortChange($event)"
+              >
+                @for (option of props.sortOptions; track option.token) {
+                  <ion-select-option [value]="option.token">
+                    {{ getSortOptionLabel(option) }}
+                  </ion-select-option>
+                }
+              </ion-select>
+            </ion-item>
+          </div>
+        }
+      </div>
+
+      <!-- New Comment Input -->
+      @if (props.showInput !== false) {
+        <div class="new-comment-section">
+          <div class="input-wrapper">
+            @if (props.inputConfig?.currentUser?.avatar) {
+              <div class="input-avatar">
+                <val-avatar [props]="props.inputConfig.currentUser.avatar"></val-avatar>
+              </div>
+            }
+
+            <div class="input-container">
+              <ion-textarea
+                [(ngModel)]="newCommentText"
+                [placeholder]="getInputPlaceholder()"
+                [maxlength]="props.inputConfig?.maxLength || 2000"
+                [disabled]="props.inputConfig?.disabled || props.loading"
+                [autoGrow]="true"
+                rows="2"
+                class="comment-textarea"
+              ></ion-textarea>
+
+              <div class="input-actions">
+                @if (props.inputConfig?.showCounter && props.inputConfig?.maxLength) {
+                  <span class="char-counter" [class.warning]="isNearLimit()">
+                    {{ newCommentText.length }} / {{ props.inputConfig.maxLength }}
+                  </span>
+                }
+
+                <ion-button
+                  [color]="props.inputConfig?.submitColor || props.color || 'primary'"
+                  [disabled]="!canSubmit()"
+                  size="small"
+                  (click)="onSubmitComment()"
+                >
+                  <ion-icon name="send-outline" slot="start"></ion-icon>
+                  {{ getSubmitLabel() }}
+                </ion-button>
+              </div>
+            </div>
+          </div>
+        </div>
+      }
+
+      @if (props.loading) {
+        <div class="loading-state">
+          @for (i of getSkeletonArray(); track i) {
+            <div class="skeleton-comment">
+              <val-skeleton [props]="{ type: 'avatar', width: '36px', height: '36px' }"></val-skeleton>
+              <div class="skeleton-content">
+                <val-skeleton [props]="{ type: 'text', width: '120px', height: '14px' }"></val-skeleton>
+                <val-skeleton [props]="{ type: 'paragraph', lines: 2 }"></val-skeleton>
+              </div>
+            </div>
+          }
+        </div>
+      } @else if (props.comments && props.comments.length > 0) {
+        <div class="comments-list" [class.with-dividers]="props.showDividers">
+          @for (comment of props.comments; track comment.token) {
+            <val-comment
+              [props]="comment"
+              (authorClick)="authorClick.emit($event)"
+              (reactionClick)="reactionClick.emit($event)"
+              (actionClick)="onCommentAction($event)"
+              (menuItemClick)="menuItemClick.emit($event)"
+              (loadMoreClick)="commentLoadMore.emit($event)"
+              (collapseToggle)="collapseToggle.emit($event)"
+            ></val-comment>
+
+            @if (props.showDividers && !$last) {
+              <div class="comment-divider"></div>
+            }
+          }
+
+          @if (props.hasMore && props.paginationMode !== 'infinite') {
+            <div class="load-more-section">
+              @if (props.loadingMore) {
+                <ion-spinner name="crescent" [color]="props.color || 'primary'"></ion-spinner>
+              } @else {
+                <ion-button
+                  fill="outline"
+                  [color]="props.color || 'primary'"
+                  expand="block"
+                  (click)="onLoadMore()"
+                >
+                  {{ displayLoadMoreLabel }}
+                </ion-button>
+              }
+            </div>
+          }
+        </div>
+
+        @if (props.paginationMode === 'infinite') {
+          <ion-infinite-scroll
+            [threshold]="props.infiniteScrollThreshold || '100px'"
+            [position]="props.infiniteScrollPosition || 'bottom'"
+            [disabled]="!props.hasMore"
+            (ionInfinite)="onInfiniteScroll($event)"
+          >
+            <ion-infinite-scroll-content
+              [loadingSpinner]="'crescent'"
+              [loadingText]="displayLoadMoreLabel"
+            ></ion-infinite-scroll-content>
+          </ion-infinite-scroll>
+        }
+      } @else {
+        <div class="empty-state">
+          <ion-icon
+            [name]="props.emptyState?.icon || 'chatbubble-ellipses-outline'"
+            class="empty-icon"
+          ></ion-icon>
+          <h4 class="empty-title">{{ getEmptyTitle() }}</h4>
+          <p class="empty-message">{{ getEmptyMessage() }}</p>
+        </div>
+      }
+    </div>
+  `, isInline: true, styles: [":host{display:block}.comment-section.loading{pointer-events:none}.section-header{display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:20px;padding-bottom:16px;border-bottom:1px solid var(--ion-color-light-shade)}.header-title{display:flex;align-items:center;gap:8px}.title-icon{font-size:24px;color:var(--ion-color-primary)}.title{margin:0;font-size:18px;font-weight:600;color:var(--ion-text-color)}.count-badge{font-size:12px;font-weight:600;--padding-start: 8px;--padding-end: 8px}.header-actions{display:flex;align-items:center;gap:8px}.sort-select-item{--padding-start: 0;--padding-end: 0;--inner-padding-end: 0;--background: transparent;--min-height: 36px}.sort-select-item ion-select{--padding-start: 8px;--padding-end: 8px;min-width:140px;font-size:14px}.sort-icon{font-size:18px;color:var(--ion-color-medium);margin-right:4px}.new-comment-section{margin-bottom:24px;padding:16px;background-color:var(--ion-color-light);border-radius:12px}.input-wrapper{display:flex;gap:12px}.input-avatar{flex-shrink:0}.input-avatar val-avatar{--size: 40px}.input-container{flex:1;min-width:0}.comment-textarea{--background: var(--ion-background-color);--padding-start: 12px;--padding-end: 12px;--padding-top: 10px;--padding-bottom: 10px;border-radius:8px;font-size:14px;min-height:60px;border:1px solid var(--ion-color-light-shade);transition:border-color .2s}.comment-textarea:focus-within{border-color:var(--ion-color-primary)}.input-actions{display:flex;align-items:center;justify-content:flex-end;gap:12px;margin-top:10px}.char-counter{font-size:12px;color:var(--ion-color-medium)}.char-counter.warning{color:var(--ion-color-warning);font-weight:500}.loading-state{display:flex;flex-direction:column;gap:20px}.skeleton-comment{display:flex;gap:12px;padding:12px 0}.skeleton-comment .skeleton-content{flex:1;display:flex;flex-direction:column;gap:8px}.comments-list.with-dividers val-comment{padding:16px 0}.comments-list.with-dividers val-comment:first-child{padding-top:0}.comment-divider{height:1px;background-color:var(--ion-color-light-shade);margin:0}.load-more-section{display:flex;justify-content:center;padding:20px 0}.load-more-section ion-button{min-width:200px}.load-more-section ion-spinner{width:28px;height:28px}.empty-state{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:48px 24px;text-align:center}.empty-icon{font-size:64px;color:var(--ion-color-medium);opacity:.5;margin-bottom:16px}.empty-title{margin:0 0 8px;font-size:18px;font-weight:600;color:var(--ion-text-color)}.empty-message{margin:0;font-size:14px;color:var(--ion-color-medium);max-width:300px}@media (max-width: 576px){.section-header{flex-direction:column;align-items:flex-start}.header-actions,.sort-select-item{width:100%}.sort-select-item ion-select{width:100%}.input-wrapper{flex-direction:column}.input-avatar{display:none}.input-actions{flex-direction:column;align-items:stretch}.input-actions ion-button{width:100%}}@media (prefers-color-scheme: dark){.new-comment-section{background-color:var(--ion-color-step-100, #1a1a1a)}.comment-textarea{--background: var(--ion-color-step-50, #121212);border-color:var(--ion-color-step-200, #2a2a2a)}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonBadge, selector: "ion-badge", inputs: ["color", "mode"] }, { kind: "component", type: IonTextarea, selector: "ion-textarea", inputs: ["autoGrow", "autocapitalize", "autofocus", "clearOnEdit", "color", "cols", "counter", "counterFormatter", "debounce", "disabled", "enterkeyhint", "errorText", "fill", "helperText", "inputmode", "label", "labelPlacement", "maxlength", "minlength", "mode", "name", "placeholder", "readonly", "required", "rows", "shape", "spellcheck", "value", "wrap"] }, { kind: "component", type: IonItem, selector: "ion-item", inputs: ["button", "color", "detail", "detailIcon", "disabled", "download", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }, { kind: "component", type: IonSelect, selector: "ion-select", inputs: ["cancelText", "color", "compareWith", "disabled", "errorText", "expandedIcon", "fill", "helperText", "interface", "interfaceOptions", "justify", "label", "labelPlacement", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "shape", "toggleIcon", "value"] }, { kind: "component", type: IonSelectOption, selector: "ion-select-option", inputs: ["disabled", "value"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonInfiniteScroll, selector: "ion-infinite-scroll", inputs: ["disabled", "position", "threshold"] }, { kind: "component", type: IonInfiniteScrollContent, selector: "ion-infinite-scroll-content", inputs: ["loadingSpinner", "loadingText"] }, { kind: "component", type: CommentComponent, selector: "val-comment", inputs: ["props"], outputs: ["authorClick", "reactionClick", "actionClick", "menuItemClick", "loadMoreClick", "collapseToggle"] }, { kind: "component", type: AvatarComponent, selector: "val-avatar", inputs: ["props"], outputs: ["onClick"] }, { kind: "component", type: SkeletonComponent, selector: "val-skeleton", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommentSectionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-comment-section', standalone: true, imports: [
+                        CommonModule,
+                        FormsModule,
+                        IonIcon,
+                        IonButton,
+                        IonBadge,
+                        IonTextarea,
+                        IonItem,
+                        IonSelect,
+                        IonSelectOption,
+                        IonSpinner,
+                        IonInfiniteScroll,
+                        IonInfiniteScrollContent,
+                        CommentComponent,
+                        AvatarComponent,
+                        SkeletonComponent,
+                    ], template: `
+    <div class="comment-section" [class.loading]="props.loading">
+      <!-- Header -->
+      <div class="section-header">
+        <div class="header-title">
+          <ion-icon name="chatbubbles-outline" class="title-icon"></ion-icon>
+          <h3 class="title">{{ displayTitle }}</h3>
+          @if (props.showCount !== false && props.count !== undefined) {
+            <ion-badge color="medium" class="count-badge">
+              {{ formatCount(props.count) }}
+            </ion-badge>
+          }
+        </div>
+
+        @if (props.sortOptions && props.sortOptions.length > 0) {
+          <div class="header-actions">
+            <ion-item lines="none" class="sort-select-item">
+              <ion-icon name="swap-vertical-outline" slot="start" class="sort-icon"></ion-icon>
+              <ion-select
+                [value]="props.selectedSort"
+                [placeholder]="props.sortLabel || 'Sort by'"
+                interface="popover"
+                (ionChange)="onSortChange($event)"
+              >
+                @for (option of props.sortOptions; track option.token) {
+                  <ion-select-option [value]="option.token">
+                    {{ getSortOptionLabel(option) }}
+                  </ion-select-option>
+                }
+              </ion-select>
+            </ion-item>
+          </div>
+        }
+      </div>
+
+      <!-- New Comment Input -->
+      @if (props.showInput !== false) {
+        <div class="new-comment-section">
+          <div class="input-wrapper">
+            @if (props.inputConfig?.currentUser?.avatar) {
+              <div class="input-avatar">
+                <val-avatar [props]="props.inputConfig.currentUser.avatar"></val-avatar>
+              </div>
+            }
+
+            <div class="input-container">
+              <ion-textarea
+                [(ngModel)]="newCommentText"
+                [placeholder]="getInputPlaceholder()"
+                [maxlength]="props.inputConfig?.maxLength || 2000"
+                [disabled]="props.inputConfig?.disabled || props.loading"
+                [autoGrow]="true"
+                rows="2"
+                class="comment-textarea"
+              ></ion-textarea>
+
+              <div class="input-actions">
+                @if (props.inputConfig?.showCounter && props.inputConfig?.maxLength) {
+                  <span class="char-counter" [class.warning]="isNearLimit()">
+                    {{ newCommentText.length }} / {{ props.inputConfig.maxLength }}
+                  </span>
+                }
+
+                <ion-button
+                  [color]="props.inputConfig?.submitColor || props.color || 'primary'"
+                  [disabled]="!canSubmit()"
+                  size="small"
+                  (click)="onSubmitComment()"
+                >
+                  <ion-icon name="send-outline" slot="start"></ion-icon>
+                  {{ getSubmitLabel() }}
+                </ion-button>
+              </div>
+            </div>
+          </div>
+        </div>
+      }
+
+      @if (props.loading) {
+        <div class="loading-state">
+          @for (i of getSkeletonArray(); track i) {
+            <div class="skeleton-comment">
+              <val-skeleton [props]="{ type: 'avatar', width: '36px', height: '36px' }"></val-skeleton>
+              <div class="skeleton-content">
+                <val-skeleton [props]="{ type: 'text', width: '120px', height: '14px' }"></val-skeleton>
+                <val-skeleton [props]="{ type: 'paragraph', lines: 2 }"></val-skeleton>
+              </div>
+            </div>
+          }
+        </div>
+      } @else if (props.comments && props.comments.length > 0) {
+        <div class="comments-list" [class.with-dividers]="props.showDividers">
+          @for (comment of props.comments; track comment.token) {
+            <val-comment
+              [props]="comment"
+              (authorClick)="authorClick.emit($event)"
+              (reactionClick)="reactionClick.emit($event)"
+              (actionClick)="onCommentAction($event)"
+              (menuItemClick)="menuItemClick.emit($event)"
+              (loadMoreClick)="commentLoadMore.emit($event)"
+              (collapseToggle)="collapseToggle.emit($event)"
+            ></val-comment>
+
+            @if (props.showDividers && !$last) {
+              <div class="comment-divider"></div>
+            }
+          }
+
+          @if (props.hasMore && props.paginationMode !== 'infinite') {
+            <div class="load-more-section">
+              @if (props.loadingMore) {
+                <ion-spinner name="crescent" [color]="props.color || 'primary'"></ion-spinner>
+              } @else {
+                <ion-button
+                  fill="outline"
+                  [color]="props.color || 'primary'"
+                  expand="block"
+                  (click)="onLoadMore()"
+                >
+                  {{ displayLoadMoreLabel }}
+                </ion-button>
+              }
+            </div>
+          }
+        </div>
+
+        @if (props.paginationMode === 'infinite') {
+          <ion-infinite-scroll
+            [threshold]="props.infiniteScrollThreshold || '100px'"
+            [position]="props.infiniteScrollPosition || 'bottom'"
+            [disabled]="!props.hasMore"
+            (ionInfinite)="onInfiniteScroll($event)"
+          >
+            <ion-infinite-scroll-content
+              [loadingSpinner]="'crescent'"
+              [loadingText]="displayLoadMoreLabel"
+            ></ion-infinite-scroll-content>
+          </ion-infinite-scroll>
+        }
+      } @else {
+        <div class="empty-state">
+          <ion-icon
+            [name]="props.emptyState?.icon || 'chatbubble-ellipses-outline'"
+            class="empty-icon"
+          ></ion-icon>
+          <h4 class="empty-title">{{ getEmptyTitle() }}</h4>
+          <p class="empty-message">{{ getEmptyMessage() }}</p>
+        </div>
+      }
+    </div>
+  `, styles: [":host{display:block}.comment-section.loading{pointer-events:none}.section-header{display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:12px;margin-bottom:20px;padding-bottom:16px;border-bottom:1px solid var(--ion-color-light-shade)}.header-title{display:flex;align-items:center;gap:8px}.title-icon{font-size:24px;color:var(--ion-color-primary)}.title{margin:0;font-size:18px;font-weight:600;color:var(--ion-text-color)}.count-badge{font-size:12px;font-weight:600;--padding-start: 8px;--padding-end: 8px}.header-actions{display:flex;align-items:center;gap:8px}.sort-select-item{--padding-start: 0;--padding-end: 0;--inner-padding-end: 0;--background: transparent;--min-height: 36px}.sort-select-item ion-select{--padding-start: 8px;--padding-end: 8px;min-width:140px;font-size:14px}.sort-icon{font-size:18px;color:var(--ion-color-medium);margin-right:4px}.new-comment-section{margin-bottom:24px;padding:16px;background-color:var(--ion-color-light);border-radius:12px}.input-wrapper{display:flex;gap:12px}.input-avatar{flex-shrink:0}.input-avatar val-avatar{--size: 40px}.input-container{flex:1;min-width:0}.comment-textarea{--background: var(--ion-background-color);--padding-start: 12px;--padding-end: 12px;--padding-top: 10px;--padding-bottom: 10px;border-radius:8px;font-size:14px;min-height:60px;border:1px solid var(--ion-color-light-shade);transition:border-color .2s}.comment-textarea:focus-within{border-color:var(--ion-color-primary)}.input-actions{display:flex;align-items:center;justify-content:flex-end;gap:12px;margin-top:10px}.char-counter{font-size:12px;color:var(--ion-color-medium)}.char-counter.warning{color:var(--ion-color-warning);font-weight:500}.loading-state{display:flex;flex-direction:column;gap:20px}.skeleton-comment{display:flex;gap:12px;padding:12px 0}.skeleton-comment .skeleton-content{flex:1;display:flex;flex-direction:column;gap:8px}.comments-list.with-dividers val-comment{padding:16px 0}.comments-list.with-dividers val-comment:first-child{padding-top:0}.comment-divider{height:1px;background-color:var(--ion-color-light-shade);margin:0}.load-more-section{display:flex;justify-content:center;padding:20px 0}.load-more-section ion-button{min-width:200px}.load-more-section ion-spinner{width:28px;height:28px}.empty-state{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:48px 24px;text-align:center}.empty-icon{font-size:64px;color:var(--ion-color-medium);opacity:.5;margin-bottom:16px}.empty-title{margin:0 0 8px;font-size:18px;font-weight:600;color:var(--ion-text-color)}.empty-message{margin:0;font-size:14px;color:var(--ion-color-medium);max-width:300px}@media (max-width: 576px){.section-header{flex-direction:column;align-items:flex-start}.header-actions,.sort-select-item{width:100%}.sort-select-item ion-select{width:100%}.input-wrapper{flex-direction:column}.input-avatar{display:none}.input-actions{flex-direction:column;align-items:stretch}.input-actions ion-button{width:100%}}@media (prefers-color-scheme: dark){.new-comment-section{background-color:var(--ion-color-step-100, #1a1a1a)}.comment-textarea{--background: var(--ion-color-step-50, #121212);border-color:var(--ion-color-step-200, #2a2a2a)}}\n"] }]
+        }], propDecorators: { props: [{
+                type: Input
+            }], sortChange: [{
+                type: Output
+            }], commentSubmit: [{
+                type: Output
+            }], loadMore: [{
+                type: Output
+            }], authorClick: [{
+                type: Output
+            }], reactionClick: [{
+                type: Output
+            }], actionClick: [{
+                type: Output
+            }], menuItemClick: [{
+                type: Output
+            }], commentLoadMore: [{
+                type: Output
+            }], collapseToggle: [{
+                type: Output
+            }], replyStart: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"comment-section.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/comment-section/comment-section.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAqB,MAAM,EAAE,MAAM,eAAe,CAAC;AAClG,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EACL,OAAO,EACP,SAAS,EACT,QAAQ,EACR,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,UAAU,EACV,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,WAAW,EACX,yBAAyB,EACzB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,uDAAuD,CAAC;;;AAgBpF,QAAQ,CAAC;IACP,kBAAkB;IAClB,aAAa;IACb,WAAW;IACX,yBAAyB;IACzB,mBAAmB;CACpB,CAAC,CAAC;AA+KH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,OAAO,uBAAuB;IAxNpC;QA2NE,iBAAiB;QACP,eAAU,GAAG,IAAI,YAAY,EAA0B,CAAC;QACxD,kBAAa,GAAG,IAAI,YAAY,EAAsB,CAAC;QACvD,aAAQ,GAAG,IAAI,YAAY,EAA+B,CAAC;QAErE,kCAAkC;QACxB,gBAAW,GAAG,IAAI,YAAY,EAA2B,CAAC;QAC1D,kBAAa,GAAG,IAAI,YAAY,EAA6B,CAAC;QAC9D,gBAAW,GAAG,IAAI,YAAY,EAA2B,CAAC;QAC1D,kBAAa,GAAG,IAAI,YAAY,EAA6B,CAAC;QAC9D,oBAAe,GAAG,IAAI,YAAY,EAAwB,CAAC;QAC3D,mBAAc,GAAG,IAAI,YAAY,EAAyC,CAAC;QAErF,cAAc;QACJ,eAAU,GAAG,IAAI,YAAY,EAA4B,CAAC;QAEpE,mBAAc,GAAG,EAAE,CAAC;QACpB,eAAU,GAAkB,IAAI,CAAC;QAEjC,iBAAY,GAAG,EAAE,CAAC;QAClB,yBAAoB,GAAG,EAAE,CAAC;QAElB,qBAAgB,GAAwB,IAAI,CAAC;QAC7C,gBAAW,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QAoMlC,wBAAmB,GAAuB,IAAI,CAAC;KAWxD;IA7MC,QAAQ;QACN,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1B,IAAI,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;YAC9B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE;gBACnE,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,CAAC;IACvC,CAAC;IAEO,kBAAkB;QACxB,OAAO,CAAC,CAAC,CACP,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;YACvD,CAAC,IAAI,CAAC,KAAK,CAAC,kBAAkB,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAC3D,CAAC;IACJ,CAAC;IAEO,kBAAkB;QACxB,QAAQ;QACR,IAAI,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;YAC1D,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAC1C,IAAI,CAAC,KAAK,CAAC,YAAY,EACvB,IAAI,CAAC,KAAK,CAAC,eAAe,EAC1B,IAAI,CAAC,KAAK,CAAC,oBAAoB,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,UAAU,CAClE,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,UAAU,CAAC;QACrD,CAAC;QAED,kBAAkB;QAClB,IAAI,IAAI,CAAC,KAAK,CAAC,kBAAkB,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;YAC7D,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAClD,IAAI,CAAC,KAAK,CAAC,YAAY,EACvB,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAC7B,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,oBAAoB,CACjD,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,oBAAoB,CAAC;QAC/E,CAAC;IACH,CAAC;IAED,WAAW,CAAC,KAAa;QACvB,IAAI,KAAK,IAAI,OAAO,EAAE,CAAC;YACrB,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC;QAChE,CAAC;QACD,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC;QAC7D,CAAC;QACD,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC1B,CAAC;IAED,kBAAkB,CAAC,MAAyB;QAC1C,IAAI,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7C,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAC7B,MAAM,CAAC,YAAY,EACnB,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,KAAK,CACvC,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,mBAAmB;QACjB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;QACtC,IAAI,MAAM,EAAE,qBAAqB,IAAI,MAAM,EAAE,YAAY,EAAE,CAAC;YAC1D,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAC7B,MAAM,CAAC,YAAY,EACnB,MAAM,CAAC,qBAAqB,EAC5B,MAAM,CAAC,WAAW,IAAI,oBAAoB,CAC3C,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,EAAE,WAAW,IAAI,oBAAoB,CAAC;IACrD,CAAC;IAED,cAAc;QACZ,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;QACtC,IAAI,MAAM,EAAE,qBAAqB,IAAI,MAAM,EAAE,YAAY,EAAE,CAAC;YAC1D,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAC7B,MAAM,CAAC,YAAY,EACnB,MAAM,CAAC,qBAAqB,EAC5B,MAAM,CAAC,WAAW,IAAI,MAAM,CAC7B,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,EAAE,WAAW,IAAI,MAAM,CAAC;IACvC,CAAC;IAED,aAAa;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC;QACpC,IAAI,KAAK,EAAE,eAAe,IAAI,KAAK,EAAE,YAAY,EAAE,CAAC;YAClD,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAC7B,KAAK,CAAC,YAAY,EAClB,KAAK,CAAC,eAAe,EACrB,KAAK,CAAC,KAAK,IAAI,iBAAiB,CACjC,CAAC;QACJ,CAAC;QACD,OAAO,KAAK,EAAE,KAAK,IAAI,iBAAiB,CAAC;IAC3C,CAAC;IAED,eAAe;QACb,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC;QACpC,IAAI,KAAK,EAAE,iBAAiB,IAAI,KAAK,EAAE,YAAY,EAAE,CAAC;YACpD,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAC7B,KAAK,CAAC,YAAY,EAClB,KAAK,CAAC,iBAAiB,EACvB,KAAK,CAAC,OAAO,IAAI,sCAAsC,CACxD,CAAC;QACJ,CAAC;QACD,OAAO,KAAK,EAAE,OAAO,IAAI,sCAAsC,CAAC;IAClE,CAAC;IAED,gBAAgB;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,CAAC,CAAC;QAC5C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED,SAAS;QACP,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,SAAS,IAAI,CAAC,CAAC;QACzD,OAAO,CACL,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,MAAM,IAAI,SAAS;YAC9C,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO;YACnB,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,QAAQ,CAClC,CAAC;IACJ,CAAC;IAED,WAAW;QACT,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,SAAS,IAAI,IAAI,CAAC;QAC5D,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,SAAS,GAAG,GAAG,CAAC;IACtD,CAAC;IAED,YAAY,CAAC,KAAkB;QAC7B,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,aAAa,CAAC,CAAC;QAE9E,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;gBACnB,MAAM;gBACN,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY;aACtC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,eAAe;QACb,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YAAE,OAAO;QAE9B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YACtB,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE;YACnC,WAAW,EAAE,IAAI,CAAC,UAAU,IAAI,SAAS;YACzC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK;SAC/B,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAED,eAAe,CAAC,KAA8B;QAC5C,+BAA+B;QAC/B,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,KAAK,OAAO,EAAE,CAAC;YACnC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,YAAY,CAAC;YACrC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;QAC7D,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,UAAU;QACR,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK;YAC9B,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,KAAkB;QACjC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK;YAC9B,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;SAC/C,CAAC,CAAC;QAEH,8EAA8E;QAC9E,kDAAkD;QAClD,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IAED,2DAA2D;IAC3D,sBAAsB;QACpB,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC5B,IAAI,CAAC,mBAAmB,CAAC,MAAuC,CAAC,QAAQ,EAAE,CAAC;YAC7E,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAClC,CAAC;IACH,CAAC;IAID,2CAA2C;IAC3C,UAAU,CAAC,YAAoB;QAC7B,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC;IACjC,CAAC;IAED,yBAAyB;IACzB,WAAW;QACT,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;+GAxOU,uBAAuB;mGAAvB,uBAAuB,gaApMxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsJT,qtGAtKC,YAAY,8BACZ,WAAW,kgBACX,OAAO,2JACP,SAAS,oPACT,QAAQ,iFACR,WAAW,iaACX,OAAO,0NACP,SAAS,kVACT,eAAe,6FACf,UAAU,yGACV,iBAAiB,+GACjB,wBAAwB,mHACxB,gBAAgB,yLAChB,eAAe,gGACf,iBAAiB;;4FAsMR,uBAAuB;kBAxNnC,SAAS;+BACE,qBAAqB,cACnB,IAAI,WACP;wBACP,YAAY;wBACZ,WAAW;wBACX,OAAO;wBACP,SAAS;wBACT,QAAQ;wBACR,WAAW;wBACX,OAAO;wBACP,SAAS;wBACT,eAAe;wBACf,UAAU;wBACV,iBAAiB;wBACjB,wBAAwB;wBACxB,gBAAgB;wBAChB,eAAe;wBACf,iBAAiB;qBAClB,YACS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsJT;8BA+CQ,KAAK;sBAAb,KAAK;gBAGI,UAAU;sBAAnB,MAAM;gBACG,aAAa;sBAAtB,MAAM;gBACG,QAAQ;sBAAjB,MAAM;gBAGG,WAAW;sBAApB,MAAM;gBACG,aAAa;sBAAtB,MAAM;gBACG,WAAW;sBAApB,MAAM;gBACG,aAAa;sBAAtB,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBACG,cAAc;sBAAvB,MAAM;gBAGG,UAAU;sBAAnB,MAAM","sourcesContent":["import { Component, Input, Output, EventEmitter, OnInit, OnDestroy, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport {\n  IonIcon,\n  IonButton,\n  IonBadge,\n  IonTextarea,\n  IonItem,\n  IonSelect,\n  IonSelectOption,\n  IonSpinner,\n  IonInfiniteScroll,\n  IonInfiniteScrollContent,\n} from '@ionic/angular/standalone';\nimport { Subscription } from 'rxjs';\nimport { addIcons } from 'ionicons';\nimport {\n  chatbubblesOutline,\n  filterOutline,\n  sendOutline,\n  chatbubbleEllipsesOutline,\n  swapVerticalOutline,\n} from 'ionicons/icons';\n\nimport { CommentComponent } from '../../molecules/comment/comment.component';\nimport { AvatarComponent } from '../../atoms/avatar/avatar.component';\nimport { SkeletonComponent } from '../../atoms/skeleton/skeleton.component';\nimport { LangService } from '../../../services/lang-provider/lang-provider.service';\nimport {\n  CommentSectionMetadata,\n  CommentSortOption,\n  CommentSortChangeEvent,\n  CommentSubmitEvent,\n  CommentSectionLoadMoreEvent,\n} from './types';\nimport {\n  CommentAuthorClickEvent,\n  CommentReactionClickEvent,\n  CommentActionClickEvent,\n  CommentMenuItemClickEvent,\n  CommentLoadMoreEvent,\n} from '../../molecules/comment/types';\n\naddIcons({\n  chatbubblesOutline,\n  filterOutline,\n  sendOutline,\n  chatbubbleEllipsesOutline,\n  swapVerticalOutline,\n});\n\n@Component({\n  selector: 'val-comment-section',\n  standalone: true,\n  imports: [\n    CommonModule,\n    FormsModule,\n    IonIcon,\n    IonButton,\n    IonBadge,\n    IonTextarea,\n    IonItem,\n    IonSelect,\n    IonSelectOption,\n    IonSpinner,\n    IonInfiniteScroll,\n    IonInfiniteScrollContent,\n    CommentComponent,\n    AvatarComponent,\n    SkeletonComponent,\n  ],\n  template: `\n    <div class=\"comment-section\" [class.loading]=\"props.loading\">\n      <!-- Header -->\n      <div class=\"section-header\">\n        <div class=\"header-title\">\n          <ion-icon name=\"chatbubbles-outline\" class=\"title-icon\"></ion-icon>\n          <h3 class=\"title\">{{ displayTitle }}</h3>\n          @if (props.showCount !== false && props.count !== undefined) {\n            <ion-badge color=\"medium\" class=\"count-badge\">\n              {{ formatCount(props.count) }}\n            </ion-badge>\n          }\n        </div>\n\n        @if (props.sortOptions && props.sortOptions.length > 0) {\n          <div class=\"header-actions\">\n            <ion-item lines=\"none\" class=\"sort-select-item\">\n              <ion-icon name=\"swap-vertical-outline\" slot=\"start\" class=\"sort-icon\"></ion-icon>\n              <ion-select\n                [value]=\"props.selectedSort\"\n                [placeholder]=\"props.sortLabel || 'Sort by'\"\n                interface=\"popover\"\n                (ionChange)=\"onSortChange($event)\"\n              >\n                @for (option of props.sortOptions; track option.token) {\n                  <ion-select-option [value]=\"option.token\">\n                    {{ getSortOptionLabel(option) }}\n                  </ion-select-option>\n                }\n              </ion-select>\n            </ion-item>\n          </div>\n        }\n      </div>\n\n      <!-- New Comment Input -->\n      @if (props.showInput !== false) {\n        <div class=\"new-comment-section\">\n          <div class=\"input-wrapper\">\n            @if (props.inputConfig?.currentUser?.avatar) {\n              <div class=\"input-avatar\">\n                <val-avatar [props]=\"props.inputConfig.currentUser.avatar\"></val-avatar>\n              </div>\n            }\n\n            <div class=\"input-container\">\n              <ion-textarea\n                [(ngModel)]=\"newCommentText\"\n                [placeholder]=\"getInputPlaceholder()\"\n                [maxlength]=\"props.inputConfig?.maxLength || 2000\"\n                [disabled]=\"props.inputConfig?.disabled || props.loading\"\n                [autoGrow]=\"true\"\n                rows=\"2\"\n                class=\"comment-textarea\"\n              ></ion-textarea>\n\n              <div class=\"input-actions\">\n                @if (props.inputConfig?.showCounter && props.inputConfig?.maxLength) {\n                  <span class=\"char-counter\" [class.warning]=\"isNearLimit()\">\n                    {{ newCommentText.length }} / {{ props.inputConfig.maxLength }}\n                  </span>\n                }\n\n                <ion-button\n                  [color]=\"props.inputConfig?.submitColor || props.color || 'primary'\"\n                  [disabled]=\"!canSubmit()\"\n                  size=\"small\"\n                  (click)=\"onSubmitComment()\"\n                >\n                  <ion-icon name=\"send-outline\" slot=\"start\"></ion-icon>\n                  {{ getSubmitLabel() }}\n                </ion-button>\n              </div>\n            </div>\n          </div>\n        </div>\n      }\n\n      @if (props.loading) {\n        <div class=\"loading-state\">\n          @for (i of getSkeletonArray(); track i) {\n            <div class=\"skeleton-comment\">\n              <val-skeleton [props]=\"{ type: 'avatar', width: '36px', height: '36px' }\"></val-skeleton>\n              <div class=\"skeleton-content\">\n                <val-skeleton [props]=\"{ type: 'text', width: '120px', height: '14px' }\"></val-skeleton>\n                <val-skeleton [props]=\"{ type: 'paragraph', lines: 2 }\"></val-skeleton>\n              </div>\n            </div>\n          }\n        </div>\n      } @else if (props.comments && props.comments.length > 0) {\n        <div class=\"comments-list\" [class.with-dividers]=\"props.showDividers\">\n          @for (comment of props.comments; track comment.token) {\n            <val-comment\n              [props]=\"comment\"\n              (authorClick)=\"authorClick.emit($event)\"\n              (reactionClick)=\"reactionClick.emit($event)\"\n              (actionClick)=\"onCommentAction($event)\"\n              (menuItemClick)=\"menuItemClick.emit($event)\"\n              (loadMoreClick)=\"commentLoadMore.emit($event)\"\n              (collapseToggle)=\"collapseToggle.emit($event)\"\n            ></val-comment>\n\n            @if (props.showDividers && !$last) {\n              <div class=\"comment-divider\"></div>\n            }\n          }\n\n          @if (props.hasMore && props.paginationMode !== 'infinite') {\n            <div class=\"load-more-section\">\n              @if (props.loadingMore) {\n                <ion-spinner name=\"crescent\" [color]=\"props.color || 'primary'\"></ion-spinner>\n              } @else {\n                <ion-button\n                  fill=\"outline\"\n                  [color]=\"props.color || 'primary'\"\n                  expand=\"block\"\n                  (click)=\"onLoadMore()\"\n                >\n                  {{ displayLoadMoreLabel }}\n                </ion-button>\n              }\n            </div>\n          }\n        </div>\n\n        @if (props.paginationMode === 'infinite') {\n          <ion-infinite-scroll\n            [threshold]=\"props.infiniteScrollThreshold || '100px'\"\n            [position]=\"props.infiniteScrollPosition || 'bottom'\"\n            [disabled]=\"!props.hasMore\"\n            (ionInfinite)=\"onInfiniteScroll($event)\"\n          >\n            <ion-infinite-scroll-content\n              [loadingSpinner]=\"'crescent'\"\n              [loadingText]=\"displayLoadMoreLabel\"\n            ></ion-infinite-scroll-content>\n          </ion-infinite-scroll>\n        }\n      } @else {\n        <div class=\"empty-state\">\n          <ion-icon\n            [name]=\"props.emptyState?.icon || 'chatbubble-ellipses-outline'\"\n            class=\"empty-icon\"\n          ></ion-icon>\n          <h4 class=\"empty-title\">{{ getEmptyTitle() }}</h4>\n          <p class=\"empty-message\">{{ getEmptyMessage() }}</p>\n        </div>\n      }\n    </div>\n  `,\n  styleUrls: ['./comment-section.component.scss'],\n})\n/**\n * val-comment-section\n *\n * An organism component that provides a complete comment section with:\n * - Header with title and count\n * - Sort/filter options\n * - New comment input\n * - Comments list with val-comment\n * - Load more pagination\n * - Empty state\n *\n * @example Basic usage\n * <val-comment-section [props]=\"{\n *   title: 'Comments',\n *   count: 42,\n *   comments: commentsArray,\n *   showInput: true\n * }\"></val-comment-section>\n *\n * @example With sorting\n * <val-comment-section [props]=\"{\n *   title: 'Reviews',\n *   count: 128,\n *   comments: reviews,\n *   sortOptions: [\n *     { token: 'newest', label: 'Newest first' },\n *     { token: 'oldest', label: 'Oldest first' },\n *     { token: 'popular', label: 'Most popular' }\n *   ],\n *   selectedSort: 'newest'\n * }\" (sortChange)=\"onSort($event)\"></val-comment-section>\n *\n * @input props: CommentSectionMetadata - Configuration for the section\n * @output sortChange - Sort option changed\n * @output commentSubmit - New comment submitted\n * @output loadMore - Load more clicked\n * @output authorClick - Comment author clicked (bubbled from val-comment)\n * @output reactionClick - Reaction clicked (bubbled)\n * @output actionClick - Action clicked (bubbled)\n * @output menuItemClick - Menu item clicked (bubbled)\n * @output commentLoadMore - Load more replies clicked (bubbled)\n * @output collapseToggle - Comment collapse toggled (bubbled)\n */\nexport class CommentSectionComponent implements OnInit, OnDestroy {\n  @Input() props: CommentSectionMetadata;\n\n  // Section events\n  @Output() sortChange = new EventEmitter<CommentSortChangeEvent>();\n  @Output() commentSubmit = new EventEmitter<CommentSubmitEvent>();\n  @Output() loadMore = new EventEmitter<CommentSectionLoadMoreEvent>();\n\n  // Bubbled events from val-comment\n  @Output() authorClick = new EventEmitter<CommentAuthorClickEvent>();\n  @Output() reactionClick = new EventEmitter<CommentReactionClickEvent>();\n  @Output() actionClick = new EventEmitter<CommentActionClickEvent>();\n  @Output() menuItemClick = new EventEmitter<CommentMenuItemClickEvent>();\n  @Output() commentLoadMore = new EventEmitter<CommentLoadMoreEvent>();\n  @Output() collapseToggle = new EventEmitter<{ token: string; collapsed: boolean }>();\n\n  // Reply state\n  @Output() replyStart = new EventEmitter<{ commentToken: string }>();\n\n  newCommentText = '';\n  replyingTo: string | null = null;\n\n  displayTitle = '';\n  displayLoadMoreLabel = '';\n\n  private langSubscription: Subscription | null = null;\n  private langService = inject(LangService);\n\n  ngOnInit(): void {\n    this.updateDisplayTexts();\n\n    if (this.hasReactiveContent()) {\n      this.langSubscription = this.langService.currentLang$.subscribe(() => {\n        this.updateDisplayTexts();\n      });\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.langSubscription?.unsubscribe();\n  }\n\n  private hasReactiveContent(): boolean {\n    return !!(\n      (this.props.titleContentKey && this.props.contentClass) ||\n      (this.props.loadMoreContentKey && this.props.contentClass)\n    );\n  }\n\n  private updateDisplayTexts(): void {\n    // Title\n    if (this.props.titleContentKey && this.props.contentClass) {\n      this.displayTitle = this.langService.getText(\n        this.props.contentClass,\n        this.props.titleContentKey,\n        this.props.titleContentFallback || this.props.title || 'Comments'\n      );\n    } else {\n      this.displayTitle = this.props.title || 'Comments';\n    }\n\n    // Load more label\n    if (this.props.loadMoreContentKey && this.props.contentClass) {\n      this.displayLoadMoreLabel = this.langService.getText(\n        this.props.contentClass,\n        this.props.loadMoreContentKey,\n        this.props.loadMoreLabel || 'Load more comments'\n      );\n    } else {\n      this.displayLoadMoreLabel = this.props.loadMoreLabel || 'Load more comments';\n    }\n  }\n\n  formatCount(count: number): string {\n    if (count >= 1000000) {\n      return (count / 1000000).toFixed(1).replace(/\\.0$/, '') + 'M';\n    }\n    if (count >= 1000) {\n      return (count / 1000).toFixed(1).replace(/\\.0$/, '') + 'K';\n    }\n    return count.toString();\n  }\n\n  getSortOptionLabel(option: CommentSortOption): string {\n    if (option.contentKey && option.contentClass) {\n      return this.langService.getText(\n        option.contentClass,\n        option.contentKey,\n        option.contentFallback || option.label\n      );\n    }\n    return option.label;\n  }\n\n  getInputPlaceholder(): string {\n    const config = this.props.inputConfig;\n    if (config?.placeholderContentKey && config?.contentClass) {\n      return this.langService.getText(\n        config.contentClass,\n        config.placeholderContentKey,\n        config.placeholder || 'Write a comment...'\n      );\n    }\n    return config?.placeholder || 'Write a comment...';\n  }\n\n  getSubmitLabel(): string {\n    const config = this.props.inputConfig;\n    if (config?.submitLabelContentKey && config?.contentClass) {\n      return this.langService.getText(\n        config.contentClass,\n        config.submitLabelContentKey,\n        config.submitLabel || 'Post'\n      );\n    }\n    return config?.submitLabel || 'Post';\n  }\n\n  getEmptyTitle(): string {\n    const empty = this.props.emptyState;\n    if (empty?.titleContentKey && empty?.contentClass) {\n      return this.langService.getText(\n        empty.contentClass,\n        empty.titleContentKey,\n        empty.title || 'No comments yet'\n      );\n    }\n    return empty?.title || 'No comments yet';\n  }\n\n  getEmptyMessage(): string {\n    const empty = this.props.emptyState;\n    if (empty?.messageContentKey && empty?.contentClass) {\n      return this.langService.getText(\n        empty.contentClass,\n        empty.messageContentKey,\n        empty.message || 'Be the first to share your thoughts!'\n      );\n    }\n    return empty?.message || 'Be the first to share your thoughts!';\n  }\n\n  getSkeletonArray(): number[] {\n    const count = this.props.skeletonCount || 3;\n    return Array(count).fill(0).map((_, i) => i);\n  }\n\n  canSubmit(): boolean {\n    const minLength = this.props.inputConfig?.minLength || 1;\n    return (\n      this.newCommentText.trim().length >= minLength &&\n      !this.props.loading &&\n      !this.props.inputConfig?.disabled\n    );\n  }\n\n  isNearLimit(): boolean {\n    const maxLength = this.props.inputConfig?.maxLength || 2000;\n    return this.newCommentText.length > maxLength * 0.9;\n  }\n\n  onSortChange(event: CustomEvent): void {\n    const selectedToken = event.detail.value;\n    const option = this.props.sortOptions?.find((o) => o.token === selectedToken);\n\n    if (option) {\n      this.sortChange.emit({\n        option,\n        previousSort: this.props.selectedSort,\n      });\n    }\n  }\n\n  onSubmitComment(): void {\n    if (!this.canSubmit()) return;\n\n    this.commentSubmit.emit({\n      content: this.newCommentText.trim(),\n      parentToken: this.replyingTo || undefined,\n      sectionToken: this.props.token,\n    });\n\n    this.newCommentText = '';\n    this.replyingTo = null;\n  }\n\n  onCommentAction(event: CommentActionClickEvent): void {\n    // Check if it's a reply action\n    if (event.action.token === 'reply') {\n      this.replyingTo = event.commentToken;\n      this.replyStart.emit({ commentToken: event.commentToken });\n    }\n\n    this.actionClick.emit(event);\n  }\n\n  onLoadMore(): void {\n    this.loadMore.emit({\n      sectionToken: this.props.token,\n      currentCount: this.props.comments?.length || 0,\n    });\n  }\n\n  onInfiniteScroll(event: CustomEvent): void {\n    this.loadMore.emit({\n      sectionToken: this.props.token,\n      currentCount: this.props.comments?.length || 0,\n    });\n\n    // The parent component should call completeInfiniteScroll() when done loading\n    // Store reference to complete the infinite scroll\n    this.infiniteScrollEvent = event;\n  }\n\n  // Call this method from parent after loading more comments\n  completeInfiniteScroll(): void {\n    if (this.infiniteScrollEvent) {\n      (this.infiniteScrollEvent.target as HTMLIonInfiniteScrollElement).complete();\n      this.infiniteScrollEvent = null;\n    }\n  }\n\n  private infiniteScrollEvent: CustomEvent | null = null;\n\n  // Method to programmatically start a reply\n  startReply(commentToken: string): void {\n    this.replyingTo = commentToken;\n  }\n\n  // Method to cancel reply\n  cancelReply(): void {\n    this.replyingTo = null;\n  }\n}\n"]}