stream-chat-angular 4.66.0 → 5.0.0-v5.1

package/esm2020/lib/attachment.service.mjs

@@ -0,0 +1,262 @@
+import { Injectable } from '@angular/core';
+import { isImageFile } from './is-image-file';
+import { BehaviorSubject } from 'rxjs';
+import { isImageAttachment } from './is-image-attachment';
+import * as i0 from "@angular/core";
+import * as i1 from "./channel.service";
+import * as i2 from "./notification.service";
+/**
+ * The `AttachmentService` manages the uploads of a message input.
+ */
+export class AttachmentService {
+    constructor(channelService, notificationService) {
+        this.channelService = channelService;
+        this.notificationService = notificationService;
+        this.attachmentUploadInProgressCounterSubject = new BehaviorSubject(0);
+        this.attachmentUploadsSubject = new BehaviorSubject([]);
+        this.attachmentUploadInProgressCounter$ =
+            this.attachmentUploadInProgressCounterSubject.asObservable();
+        this.attachmentUploads$ = this.attachmentUploadsSubject.asObservable();
+    }
+    /**
+     * Resets the attachments uploads (for example after the message with the attachments sent successfully)
+     */
+    resetAttachmentUploads() {
+        this.attachmentUploadsSubject.next([]);
+    }
+    /**
+     * Uploads the selected files, and creates preview for image files. The result is propagated throught the `attachmentUploads$` stream.
+     * @param fileList The files selected by the user
+     * @returns A promise with the result
+     */
+    async filesSelected(fileList) {
+        if (!fileList) {
+            return;
+        }
+        const imageFiles = [];
+        const dataFiles = [];
+        const videoFiles = [];
+        Array.from(fileList).forEach((file) => {
+            if (isImageFile(file)) {
+                imageFiles.push(file);
+            }
+            else if (file.type.startsWith('video/')) {
+                videoFiles.push(file);
+            }
+            else {
+                dataFiles.push(file);
+            }
+        });
+        imageFiles.forEach((f) => this.createPreview(f));
+        const newUploads = [
+            ...imageFiles.map((file) => ({
+                file,
+                state: 'uploading',
+                type: 'image',
+            })),
+            ...videoFiles.map((file) => ({
+                file,
+                state: 'uploading',
+                type: 'video',
+            })),
+            ...dataFiles.map((file) => ({
+                file,
+                state: 'uploading',
+                type: 'file',
+            })),
+        ];
+        this.attachmentUploadsSubject.next([
+            ...this.attachmentUploadsSubject.getValue(),
+            ...newUploads,
+        ]);
+        await this.uploadAttachments(newUploads);
+    }
+    /**
+     * You can add custom `image`, `video` and `file` attachments using this method.
+     *
+     * Note: If you just want to use your own CDN for file uploads, you don't necessary need this method, you can just specify you own upload function in the [`ChannelService`](./ChannelService.mdx)
+     * @param attachment
+     */
+    addAttachment(attachment) {
+        attachment.isCustomAttachment = true;
+        this.createFromAttachments([attachment]);
+    }
+    /**
+     * Retries to upload an attachment.
+     * @param file
+     * @returns A promise with the result
+     */
+    async retryAttachmentUpload(file) {
+        const attachmentUploads = this.attachmentUploadsSubject.getValue();
+        const upload = attachmentUploads.find((u) => u.file === file);
+        if (!upload) {
+            return;
+        }
+        upload.state = 'uploading';
+        this.attachmentUploadsSubject.next([...attachmentUploads]);
+        await this.uploadAttachments([upload]);
+    }
+    /**
+     * Deletes an attachment, the attachment can have any state (`error`, `uploading` or `success`).
+     * @param upload
+     */
+    async deleteAttachment(upload) {
+        const attachmentUploads = this.attachmentUploadsSubject.getValue();
+        let result;
+        if (upload.state === 'success' &&
+            !upload.fromAttachment?.isCustomAttachment) {
+            try {
+                await this.channelService.deleteAttachment(upload);
+                result = [...attachmentUploads];
+                const index = attachmentUploads.indexOf(upload);
+                result.splice(index, 1);
+            }
+            catch (error) {
+                result = attachmentUploads;
+                this.notificationService.addTemporaryNotification('streamChat.Error deleting attachment');
+            }
+        }
+        else {
+            result = [...attachmentUploads];
+            const index = attachmentUploads.indexOf(upload);
+            result.splice(index, 1);
+        }
+        this.attachmentUploadsSubject.next([...result]);
+    }
+    /**
+     * Maps the current uploads to a format that can be sent along with the message to the Stream API.
+     * @returns the attachments
+     */
+    mapToAttachments() {
+        const attachmentUploads = this.attachmentUploadsSubject.getValue();
+        return attachmentUploads
+            .filter((r) => r.state === 'success')
+            .map((r) => {
+            const attachment = {
+                type: r.type,
+            };
+            if (r.fromAttachment) {
+                return r.fromAttachment;
+            }
+            else {
+                attachment.mime_type = r.file?.type;
+                if (r.type === 'image') {
+                    attachment.fallback = r.file?.name;
+                    attachment.image_url = r.url;
+                }
+                else {
+                    attachment.asset_url = r.url;
+                    attachment.title = r.file?.name;
+                    attachment.file_size = r.file?.size;
+                    attachment.thumb_url = r.thumb_url;
+                }
+            }
+            return attachment;
+        });
+    }
+    /**
+     * Maps attachments received from the Stream API to uploads. This is useful when editing a message.
+     * @param attachments Attachemnts received with the message
+     */
+    createFromAttachments(attachments) {
+        const attachmentUploads = [];
+        attachments.forEach((attachment) => {
+            if (isImageAttachment(attachment)) {
+                attachmentUploads.push({
+                    url: (attachment.img_url ||
+                        attachment.thumb_url ||
+                        attachment.image_url),
+                    state: 'success',
+                    type: 'image',
+                    file: {
+                        name: attachment.fallback,
+                        type: attachment.mime_type,
+                    },
+                    fromAttachment: attachment,
+                });
+            }
+            else if (attachment.type === 'file' || attachment.type === 'video') {
+                attachmentUploads.push({
+                    url: attachment.asset_url,
+                    state: 'success',
+                    file: {
+                        name: attachment.title,
+                        size: attachment.file_size,
+                        type: attachment.mime_type,
+                    },
+                    type: attachment.type,
+                    thumb_url: attachment.thumb_url,
+                    fromAttachment: attachment,
+                });
+            }
+        });
+        if (attachmentUploads.length > 0) {
+            this.attachmentUploadsSubject.next([
+                ...this.attachmentUploadsSubject.getValue(),
+                ...attachmentUploads,
+            ]);
+        }
+    }
+    createPreview(file) {
+        const reader = new FileReader();
+        reader.onload = (event) => {
+            const attachmentUploads = this.attachmentUploadsSubject.getValue();
+            const upload = attachmentUploads.find((upload) => upload.file === file);
+            if (!upload) {
+                return;
+            }
+            upload.previewUri = event.target?.result || undefined;
+            this.attachmentUploadsSubject.next([...attachmentUploads]);
+        };
+        reader.readAsDataURL(file);
+    }
+    async uploadAttachments(uploads) {
+        this.attachmentUploadInProgressCounterSubject.next(this.attachmentUploadInProgressCounterSubject.getValue() + 1);
+        const result = await this.channelService.uploadAttachments(uploads);
+        const attachmentUploads = this.attachmentUploadsSubject.getValue();
+        result.forEach((r) => {
+            const upload = attachmentUploads.find((upload) => upload.file === r.file);
+            if (!upload) {
+                if (r.url) {
+                    void this.channelService.deleteAttachment(r);
+                }
+                return;
+            }
+            upload.state = r.state;
+            upload.url = r.url;
+            upload.thumb_url = r.thumb_url;
+            if (upload.state === 'error') {
+                upload.errorReason = r.errorReason;
+                upload.errorExtraInfo = r.errorExtraInfo;
+                let errorKey;
+                const translateParams = { name: upload.file.name };
+                switch (upload.errorReason) {
+                    case 'file-extension':
+                        errorKey =
+                            'streamChat.Error uploading file, extension not supported';
+                        translateParams.ext = upload.errorExtraInfo?.[0]?.param;
+                        break;
+                    case 'file-size':
+                        errorKey =
+                            'streamChat.Error uploading file, maximum file size exceeded';
+                        translateParams.limit = upload.errorExtraInfo?.[0]?.param;
+                        break;
+                    default:
+                        errorKey = 'streamChat.Error uploading file';
+                }
+                this.notificationService.addTemporaryNotification(errorKey, 'error', undefined, translateParams);
+            }
+        });
+        this.attachmentUploadInProgressCounterSubject.next(this.attachmentUploadInProgressCounterSubject.getValue() - 1);
+        this.attachmentUploadsSubject.next([...attachmentUploads]);
+    }
+}
+AttachmentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AttachmentService, deps: [{ token: i1.ChannelService }, { token: i2.NotificationService }], target: i0.ɵɵFactoryTarget.Injectable });
+AttachmentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AttachmentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AttachmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ChannelService }, { type: i2.NotificationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attachment.service.js","sourceRoot":"","sources":["../../../../projects/stream-chat-angular/src/lib/attachment.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { isImageFile } from './is-image-file';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { Attachment } from 'stream-chat';\nimport { ChannelService } from './channel.service';\nimport { isImageAttachment } from './is-image-attachment';\nimport { NotificationService } from './notification.service';\nimport { AttachmentUpload, DefaultStreamChatGenerics } from './types';\n\n/**\n * The `AttachmentService` manages the uploads of a message input.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class AttachmentService<\n  T extends DefaultStreamChatGenerics = DefaultStreamChatGenerics\n> {\n  /**\n   * Emits the number of uploads in progress.\n   */\n  attachmentUploadInProgressCounter$: Observable<number>;\n  /**\n   * Emits the state of the uploads ([`AttachmentUpload[]`](https://github.com/GetStream/stream-chat-angular/blob/master/projects/stream-chat-angular/src/lib/types.ts)), it adds a state (`success`, `error` or `uploading`) to each file the user selects for upload. It is used by the [`AttachmentPreviewList`](../components/AttachmentPreviewListComponent.mdx) to display the attachment previews.\n   */\n  attachmentUploads$: Observable<AttachmentUpload[]>;\n  private attachmentUploadInProgressCounterSubject =\n    new BehaviorSubject<number>(0);\n  private attachmentUploadsSubject = new BehaviorSubject<AttachmentUpload[]>(\n    []\n  );\n\n  constructor(\n    private channelService: ChannelService,\n    private notificationService: NotificationService\n  ) {\n    this.attachmentUploadInProgressCounter$ =\n      this.attachmentUploadInProgressCounterSubject.asObservable();\n    this.attachmentUploads$ = this.attachmentUploadsSubject.asObservable();\n  }\n\n  /**\n   * Resets the attachments uploads (for example after the message with the attachments sent successfully)\n   */\n  resetAttachmentUploads() {\n    this.attachmentUploadsSubject.next([]);\n  }\n\n  /**\n   * Uploads the selected files, and creates preview for image files. The result is propagated throught the `attachmentUploads$` stream.\n   * @param fileList The files selected by the user\n   * @returns A promise with the result\n   */\n  async filesSelected(fileList: FileList | null) {\n    if (!fileList) {\n      return;\n    }\n    const imageFiles: File[] = [];\n    const dataFiles: File[] = [];\n    const videoFiles: File[] = [];\n\n    Array.from(fileList).forEach((file) => {\n      if (isImageFile(file)) {\n        imageFiles.push(file);\n      } else if (file.type.startsWith('video/')) {\n        videoFiles.push(file);\n      } else {\n        dataFiles.push(file);\n      }\n    });\n    imageFiles.forEach((f) => this.createPreview(f));\n    const newUploads = [\n      ...imageFiles.map((file) => ({\n        file,\n        state: 'uploading' as const,\n        type: 'image' as const,\n      })),\n      ...videoFiles.map((file) => ({\n        file,\n        state: 'uploading' as const,\n        type: 'video' as const,\n      })),\n      ...dataFiles.map((file) => ({\n        file,\n        state: 'uploading' as const,\n        type: 'file' as const,\n      })),\n    ];\n    this.attachmentUploadsSubject.next([\n      ...this.attachmentUploadsSubject.getValue(),\n      ...newUploads,\n    ]);\n    await this.uploadAttachments(newUploads);\n  }\n\n  /**\n   * You can add custom `image`, `video` and `file` attachments using this method.\n   *\n   * Note: If you just want to use your own CDN for file uploads, you don't necessary need this method, you can just specify you own upload function in the [`ChannelService`](./ChannelService.mdx)\n   * @param attachment\n   */\n  addAttachment(attachment: Attachment<T>) {\n    attachment.isCustomAttachment = true;\n    this.createFromAttachments([attachment]);\n  }\n\n  /**\n   * Retries to upload an attachment.\n   * @param file\n   * @returns A promise with the result\n   */\n  async retryAttachmentUpload(file: File) {\n    const attachmentUploads = this.attachmentUploadsSubject.getValue();\n    const upload = attachmentUploads.find((u) => u.file === file);\n    if (!upload) {\n      return;\n    }\n    upload.state = 'uploading';\n    this.attachmentUploadsSubject.next([...attachmentUploads]);\n    await this.uploadAttachments([upload]);\n  }\n\n  /**\n   * Deletes an attachment, the attachment can have any state (`error`, `uploading` or `success`).\n   * @param upload\n   */\n  async deleteAttachment(upload: AttachmentUpload) {\n    const attachmentUploads = this.attachmentUploadsSubject.getValue();\n    let result!: AttachmentUpload[];\n    if (\n      upload.state === 'success' &&\n      !upload.fromAttachment?.isCustomAttachment\n    ) {\n      try {\n        await this.channelService.deleteAttachment(upload);\n        result = [...attachmentUploads];\n        const index = attachmentUploads.indexOf(upload);\n        result.splice(index, 1);\n      } catch (error) {\n        result = attachmentUploads;\n        this.notificationService.addTemporaryNotification(\n          'streamChat.Error deleting attachment'\n        );\n      }\n    } else {\n      result = [...attachmentUploads];\n      const index = attachmentUploads.indexOf(upload);\n      result.splice(index, 1);\n    }\n    this.attachmentUploadsSubject.next([...result]);\n  }\n\n  /**\n   * Maps the current uploads to a format that can be sent along with the message to the Stream API.\n   * @returns the attachments\n   */\n  mapToAttachments() {\n    const attachmentUploads = this.attachmentUploadsSubject.getValue();\n    return attachmentUploads\n      .filter((r) => r.state === 'success')\n      .map((r) => {\n        const attachment: Attachment = {\n          type: r.type,\n        };\n        if (r.fromAttachment) {\n          return r.fromAttachment;\n        } else {\n          attachment.mime_type = r.file?.type;\n          if (r.type === 'image') {\n            attachment.fallback = r.file?.name;\n            attachment.image_url = r.url;\n          } else {\n            attachment.asset_url = r.url;\n            attachment.title = r.file?.name;\n            attachment.file_size = r.file?.size;\n            attachment.thumb_url = r.thumb_url;\n          }\n        }\n\n        return attachment;\n      });\n  }\n\n  /**\n   * Maps attachments received from the Stream API to uploads. This is useful when editing a message.\n   * @param attachments Attachemnts received with the message\n   */\n  createFromAttachments(attachments: Attachment<T>[]) {\n    const attachmentUploads: AttachmentUpload[] = [];\n    attachments.forEach((attachment) => {\n      if (isImageAttachment(attachment)) {\n        attachmentUploads.push({\n          url: (attachment.img_url ||\n            attachment.thumb_url ||\n            attachment.image_url) as string,\n          state: 'success',\n          type: 'image',\n          file: {\n            name: attachment.fallback,\n            type: attachment.mime_type,\n          } as File,\n          fromAttachment: attachment,\n        });\n      } else if (attachment.type === 'file' || attachment.type === 'video') {\n        attachmentUploads.push({\n          url: attachment.asset_url,\n          state: 'success',\n          file: {\n            name: attachment.title,\n            size: attachment.file_size,\n            type: attachment.mime_type,\n          } as File,\n          type: attachment.type,\n          thumb_url: attachment.thumb_url,\n          fromAttachment: attachment,\n        });\n      }\n    });\n\n    if (attachmentUploads.length > 0) {\n      this.attachmentUploadsSubject.next([\n        ...this.attachmentUploadsSubject.getValue(),\n        ...attachmentUploads,\n      ]);\n    }\n  }\n\n  private createPreview(file: File) {\n    const reader = new FileReader();\n    reader.onload = (event) => {\n      const attachmentUploads = this.attachmentUploadsSubject.getValue();\n      const upload = attachmentUploads.find((upload) => upload.file === file);\n      if (!upload) {\n        return;\n      }\n      upload.previewUri = event.target?.result || undefined;\n      this.attachmentUploadsSubject.next([...attachmentUploads]);\n    };\n    reader.readAsDataURL(file as Blob);\n  }\n\n  private async uploadAttachments(uploads: AttachmentUpload[]) {\n    this.attachmentUploadInProgressCounterSubject.next(\n      this.attachmentUploadInProgressCounterSubject.getValue() + 1\n    );\n    const result = await this.channelService.uploadAttachments(uploads);\n    const attachmentUploads = this.attachmentUploadsSubject.getValue();\n    result.forEach((r) => {\n      const upload = attachmentUploads.find((upload) => upload.file === r.file);\n      if (!upload) {\n        if (r.url) {\n          void this.channelService.deleteAttachment(r);\n        }\n        return;\n      }\n      upload.state = r.state;\n      upload.url = r.url;\n      upload.thumb_url = r.thumb_url;\n      if (upload.state === 'error') {\n        upload.errorReason = r.errorReason;\n        upload.errorExtraInfo = r.errorExtraInfo;\n        let errorKey;\n        const translateParams: { name: string; ext?: string; limit?: string } =\n          { name: upload.file.name };\n        switch (upload.errorReason) {\n          case 'file-extension':\n            errorKey =\n              'streamChat.Error uploading file, extension not supported';\n            translateParams.ext = upload.errorExtraInfo?.[0]?.param;\n            break;\n          case 'file-size':\n            errorKey =\n              'streamChat.Error uploading file, maximum file size exceeded';\n            translateParams.limit = upload.errorExtraInfo?.[0]?.param;\n            break;\n          default:\n            errorKey = 'streamChat.Error uploading file';\n        }\n        this.notificationService.addTemporaryNotification(\n          errorKey,\n          'error',\n          undefined,\n          translateParams\n        );\n      }\n    });\n    this.attachmentUploadInProgressCounterSubject.next(\n      this.attachmentUploadInProgressCounterSubject.getValue() - 1\n    );\n    this.attachmentUploadsSubject.next([...attachmentUploads]);\n  }\n}\n"]}

package/esm2020/lib/avatar/avatar.component.mjs

@@ -0,0 +1,163 @@
+import { Component, Input, } from '@angular/core';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../chat-client.service";
+import * as i2 from "@angular/common";
+/**
+ * The `Avatar` component displays the provided image, with fallback to the first letter of the optional name input.
+ */
+export class AvatarComponent {
+    constructor(chatClientService, ngZone, cdRef) {
+        this.chatClientService = chatClientService;
+        this.ngZone = ngZone;
+        this.cdRef = cdRef;
+        /**
+         * The size in pixels of the avatar image.
+         */
+        this.size = 32;
+        /**
+         * If a channel avatar is displayed, and if the channel has exactly two members a green dot is displayed if the other member is online. Set this flag to `false` to turn off this behavior.
+         */
+        this.showOnlineIndicator = true;
+        /**
+         * If channel/user image isn't provided the initials of the name of the channel/user is shown instead, you can choose how the initals should be computed
+         */
+        this.initialsType = 'first-letter-of-first-word';
+        this.isError = false;
+        this.isOnline = false;
+        this.initials = '';
+        this.isViewInited = false;
+        this.subscriptions = [];
+    }
+    ngOnInit() {
+        this.subscriptions.push(this.chatClientService.user$.subscribe((u) => {
+            if (u?.id !== this.userId) {
+                this.userId = u?.id;
+                if (this.type || this.channel || this.name) {
+                    this.setInitials();
+                    this.setFallbackChannelImage();
+                    this.updateIsOnlineSubscription();
+                }
+                if (this.isViewInited) {
+                    this.cdRef.detectChanges();
+                }
+            }
+        }));
+    }
+    ngOnChanges(changes) {
+        if (changes['channel']) {
+            this.updateIsOnlineSubscription();
+        }
+        if (changes.type || changes.name || changes.channel) {
+            this.setInitials();
+        }
+        if (changes.type || changes.channel) {
+            this.setFallbackChannelImage();
+        }
+    }
+    setFallbackChannelImage() {
+        if (this.type !== 'channel') {
+            this.fallbackChannelImage = undefined;
+        }
+        else {
+            const otherMember = this.getOtherMemberIfOneToOneChannel();
+            if (otherMember) {
+                this.fallbackChannelImage = otherMember.image;
+            }
+            else {
+                this.fallbackChannelImage = undefined;
+            }
+        }
+    }
+    setInitials() {
+        let result = '';
+        if (this.type === 'user') {
+            result = this.name?.toString() || '';
+        }
+        else if (this.type === 'channel') {
+            if (this.channel?.data?.name) {
+                result = this.channel?.data?.name;
+            }
+            else {
+                const otherMember = this.getOtherMemberIfOneToOneChannel();
+                if (otherMember) {
+                    result = otherMember.name || otherMember.id || '';
+                }
+                else {
+                    result = '#';
+                }
+            }
+        }
+        const words = result.split(' ');
+        let initials;
+        if (this.initialsType === 'first-letter-of-each-word') {
+            initials = words.map((w) => w.charAt(0) || '').join('');
+        }
+        else {
+            initials = words[0].charAt(0) || '';
+        }
+        this.initials = initials;
+    }
+    updateIsOnlineSubscription() {
+        if (this.channel) {
+            const otherMember = this.getOtherMemberIfOneToOneChannel();
+            if (otherMember) {
+                this.isOnline = otherMember.online || false;
+                this.isOnlineSubscription = this.chatClientService.events$
+                    .pipe(filter((e) => e.eventType === 'user.presence.changed'))
+                    .subscribe((event) => {
+                    if (event.event.user?.id === otherMember.id) {
+                        this.ngZone.run(() => {
+                            this.isOnline = event.event.user?.online || false;
+                        });
+                    }
+                });
+            }
+            else {
+                this.isOnline = false;
+                this.isOnlineSubscription?.unsubscribe();
+            }
+        }
+        else {
+            this.isOnline = false;
+            this.isOnlineSubscription?.unsubscribe();
+        }
+    }
+    ngAfterViewInit() {
+        this.isViewInited = true;
+    }
+    getOtherMemberIfOneToOneChannel() {
+        const otherMembers = Object.values(this.channel?.state?.members || {}).filter((m) => m.user_id !== this.userId);
+        if (otherMembers.length === 1) {
+            return otherMembers[0].user;
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+AvatarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AvatarComponent, deps: [{ token: i1.ChatClientService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+AvatarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: AvatarComponent, selector: "stream-avatar", inputs: { name: "name", imageUrl: "imageUrl", size: "size", location: "location", channel: "channel", user: "user", type: "type", showOnlineIndicator: "showOnlineIndicator", initialsType: "initialsType" }, usesOnChanges: true, ngImport: i0, template: "<div\n  class=\"str-chat__avatar str-chat__avatar--circle stream-chat__avatar--{{\n    location\n  }}\"\n  title=\"{{ name }}\"\n  [ngStyle]=\"{\n    flexBasis: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    fontSize:\n      initialsType === 'first-letter-of-first-word'\n        ? 'calc(var(--str-chat__spacing-px, 1px) * ' + size / 2 + ')'\n        : 'calc(var(--str-chat__spacing-px, 1px) * ' + size / 3 + ')',\n    height: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    lineHeight: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    width: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')'\n  }\"\n>\n  <img\n    *ngIf=\"(imageUrl || fallbackChannelImage) && !isError; else fallback\"\n    class=\"str-chat__avatar-image str-chat__avatar-image\"\n    data-testid=\"avatar-img\"\n    fetchpriority=\"high\"\n    src=\"{{ imageUrl || fallbackChannelImage }}\"\n    alt=\"{{ initials }}\"\n    [ngStyle]=\"{\n      flexBasis: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n      height: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n      objectFit: 'cover',\n      width: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')'\n    }\"\n    (error)=\"isError = true\"\n  />\n  <ng-template #fallback>\n    <div data-testid=\"fallback-img\" class=\"str-chat__avatar-fallback\">\n      {{ initials }}\n    </div>\n  </ng-template>\n  <div\n    *ngIf=\"isOnline && showOnlineIndicator\"\n    data-testid=\"online-indicator\"\n    class=\"str-chat__avatar--online-indicator\"\n  ></div>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AvatarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'stream-avatar', template: "<div\n  class=\"str-chat__avatar str-chat__avatar--circle stream-chat__avatar--{{\n    location\n  }}\"\n  title=\"{{ name }}\"\n  [ngStyle]=\"{\n    flexBasis: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    fontSize:\n      initialsType === 'first-letter-of-first-word'\n        ? 'calc(var(--str-chat__spacing-px, 1px) * ' + size / 2 + ')'\n        : 'calc(var(--str-chat__spacing-px, 1px) * ' + size / 3 + ')',\n    height: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    lineHeight: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    width: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')'\n  }\"\n>\n  <img\n    *ngIf=\"(imageUrl || fallbackChannelImage) && !isError; else fallback\"\n    class=\"str-chat__avatar-image str-chat__avatar-image\"\n    data-testid=\"avatar-img\"\n    fetchpriority=\"high\"\n    src=\"{{ imageUrl || fallbackChannelImage }}\"\n    alt=\"{{ initials }}\"\n    [ngStyle]=\"{\n      flexBasis: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n      height: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n      objectFit: 'cover',\n      width: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')'\n    }\"\n    (error)=\"isError = true\"\n  />\n  <ng-template #fallback>\n    <div data-testid=\"fallback-img\" class=\"str-chat__avatar-fallback\">\n      {{ initials }}\n    </div>\n  </ng-template>\n  <div\n    *ngIf=\"isOnline && showOnlineIndicator\"\n    data-testid=\"online-indicator\"\n    class=\"str-chat__avatar--online-indicator\"\n  ></div>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ChatClientService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { name: [{
+                type: Input
+            }], imageUrl: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], location: [{
+                type: Input
+            }], channel: [{
+                type: Input
+            }], user: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], showOnlineIndicator: [{
+                type: Input
+            }], initialsType: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avatar.component.js","sourceRoot":"","sources":["../../../../../projects/stream-chat-angular/src/lib/avatar/avatar.component.ts","../../../../../projects/stream-chat-angular/src/lib/avatar/avatar.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  NgZone,\n  OnChanges,\n  OnInit,\n  SimpleChanges,\n} from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { filter } from 'rxjs/operators';\nimport { Channel, User } from 'stream-chat';\nimport { ChatClientService } from '../chat-client.service';\nimport {\n  AvatarLocation,\n  AvatarType,\n  DefaultStreamChatGenerics,\n} from '../types';\n\n/**\n * The `Avatar` component displays the provided image, with fallback to the first letter of the optional name input.\n */\n@Component({\n  selector: 'stream-avatar',\n  templateUrl: './avatar.component.html',\n  styleUrls: ['./avatar.component.scss'],\n})\nexport class AvatarComponent\n  implements OnChanges, OnInit, OnChanges, AfterViewInit\n{\n  /**\n   * An optional name of the image, used for fallback image or image title (if `imageUrl` is provided)\n   */\n  @Input() name: string | undefined;\n  /**\n   * The URL of the image to be displayed. If the image can't be displayed the first letter of the name input is displayed.\n   */\n  @Input() imageUrl: string | undefined;\n  /**\n   * The size in pixels of the avatar image.\n   */\n  @Input() size = 32;\n  /**\n   * The location the avatar will be displayed in\n   */\n  @Input() location: AvatarLocation | undefined;\n  /**\n   * The channel the avatar belongs to (if avatar of a channel is displayed)\n   */\n  @Input() channel?: Channel<DefaultStreamChatGenerics>;\n  /**\n   * The user the avatar belongs to (if avatar of a user is displayed)\n   */\n  @Input() user?: User<DefaultStreamChatGenerics>;\n  /**\n   * The type of the avatar: channel if channel avatar is displayed, user if user avatar is displayed\n   */\n  @Input() type: AvatarType | undefined;\n  /**\n   * If a channel avatar is displayed, and if the channel has exactly two members a green dot is displayed if the other member is online. Set this flag to `false` to turn off this behavior.\n   */\n  @Input() showOnlineIndicator = true;\n  /**\n   * If channel/user image isn't provided the initials of the name of the channel/user is shown instead, you can choose how the initals should be computed\n   */\n  @Input() initialsType:\n    | 'first-letter-of-first-word'\n    | 'first-letter-of-each-word' = 'first-letter-of-first-word';\n  isError = false;\n  isOnline = false;\n  private isOnlineSubscription?: Subscription;\n  initials: string = '';\n  fallbackChannelImage: string | undefined;\n  private userId?: string;\n  private isViewInited = false;\n  private subscriptions: Subscription[] = [];\n\n  constructor(\n    private chatClientService: ChatClientService,\n    private ngZone: NgZone,\n    private cdRef: ChangeDetectorRef\n  ) {}\n\n  ngOnInit(): void {\n    this.subscriptions.push(\n      this.chatClientService.user$.subscribe((u) => {\n        if (u?.id !== this.userId) {\n          this.userId = u?.id;\n          if (this.type || this.channel || this.name) {\n            this.setInitials();\n            this.setFallbackChannelImage();\n            this.updateIsOnlineSubscription();\n          }\n          if (this.isViewInited) {\n            this.cdRef.detectChanges();\n          }\n        }\n      })\n    );\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['channel']) {\n      this.updateIsOnlineSubscription();\n    }\n    if (changes.type || changes.name || changes.channel) {\n      this.setInitials();\n    }\n\n    if (changes.type || changes.channel) {\n      this.setFallbackChannelImage();\n    }\n  }\n\n  private setFallbackChannelImage() {\n    if (this.type !== 'channel') {\n      this.fallbackChannelImage = undefined;\n    } else {\n      const otherMember = this.getOtherMemberIfOneToOneChannel();\n      if (otherMember) {\n        this.fallbackChannelImage = otherMember.image;\n      } else {\n        this.fallbackChannelImage = undefined;\n      }\n    }\n  }\n\n  private setInitials() {\n    let result: string = '';\n    if (this.type === 'user') {\n      result = this.name?.toString() || '';\n    } else if (this.type === 'channel') {\n      if (this.channel?.data?.name) {\n        result = this.channel?.data?.name;\n      } else {\n        const otherMember = this.getOtherMemberIfOneToOneChannel();\n        if (otherMember) {\n          result = otherMember.name || otherMember.id || '';\n        } else {\n          result = '#';\n        }\n      }\n    }\n\n    const words = result.split(' ');\n    let initials: string;\n    if (this.initialsType === 'first-letter-of-each-word') {\n      initials = words.map((w) => w.charAt(0) || '').join('');\n    } else {\n      initials = words[0].charAt(0) || '';\n    }\n    this.initials = initials;\n  }\n\n  private updateIsOnlineSubscription() {\n    if (this.channel) {\n      const otherMember = this.getOtherMemberIfOneToOneChannel();\n      if (otherMember) {\n        this.isOnline = otherMember.online || false;\n        this.isOnlineSubscription = this.chatClientService.events$\n          .pipe(filter((e) => e.eventType === 'user.presence.changed'))\n          .subscribe((event) => {\n            if (event.event.user?.id === otherMember.id) {\n              this.ngZone.run(() => {\n                this.isOnline = event.event.user?.online || false;\n              });\n            }\n          });\n      } else {\n        this.isOnline = false;\n        this.isOnlineSubscription?.unsubscribe();\n      }\n    } else {\n      this.isOnline = false;\n      this.isOnlineSubscription?.unsubscribe();\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.isViewInited = true;\n  }\n\n  private getOtherMemberIfOneToOneChannel() {\n    const otherMembers = Object.values(\n      this.channel?.state?.members || {}\n    ).filter((m) => m.user_id !== this.userId);\n    if (otherMembers.length === 1) {\n      return otherMembers[0].user;\n    } else {\n      return undefined;\n    }\n  }\n}\n","<div\n  class=\"str-chat__avatar str-chat__avatar--circle stream-chat__avatar--{{\n    location\n  }}\"\n  title=\"{{ name }}\"\n  [ngStyle]=\"{\n    flexBasis: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    fontSize:\n      initialsType === 'first-letter-of-first-word'\n        ? 'calc(var(--str-chat__spacing-px, 1px) * ' + size / 2 + ')'\n        : 'calc(var(--str-chat__spacing-px, 1px) * ' + size / 3 + ')',\n    height: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    lineHeight: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n    width: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')'\n  }\"\n>\n  <img\n    *ngIf=\"(imageUrl || fallbackChannelImage) && !isError; else fallback\"\n    class=\"str-chat__avatar-image str-chat__avatar-image\"\n    data-testid=\"avatar-img\"\n    fetchpriority=\"high\"\n    src=\"{{ imageUrl || fallbackChannelImage }}\"\n    alt=\"{{ initials }}\"\n    [ngStyle]=\"{\n      flexBasis: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n      height: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')',\n      objectFit: 'cover',\n      width: 'calc(var(--str-chat__spacing-px, 1px) * ' + size + ')'\n    }\"\n    (error)=\"isError = true\"\n  />\n  <ng-template #fallback>\n    <div data-testid=\"fallback-img\" class=\"str-chat__avatar-fallback\">\n      {{ initials }}\n    </div>\n  </ng-template>\n  <div\n    *ngIf=\"isOnline && showOnlineIndicator\"\n    data-testid=\"online-indicator\"\n    class=\"str-chat__avatar--online-indicator\"\n  ></div>\n</div>\n"]}

package/esm2020/lib/avatar-placeholder/avatar-placeholder.component.mjs

@@ -0,0 +1,74 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../custom-templates.service";
+import * as i2 from "@angular/common";
+import * as i3 from "../avatar/avatar.component";
+/**
+ * The `AvatarPlaceholder` component displays the [default avatar](./AvatarComponent.mdx) unless a [custom template](../services/CustomTemplatesService.mdx) is provided. This component is used by the SDK internally, you likely won't need to use it.
+ */
+export class AvatarPlaceholderComponent {
+    constructor(customTemplatesService) {
+        this.customTemplatesService = customTemplatesService;
+        /**
+         * The size in pixels of the avatar image.
+         */
+        this.size = 32;
+        /**
+         * If channel/user image isn't provided the initials of the name of the channel/user is shown instead, you can choose how the initals should be computed
+         */
+        this.initialsType = 'first-letter-of-first-word';
+        /**
+         * If a channel avatar is displayed, and if the channel has exactly two members a green dot is displayed if the other member is online. Set this flag to `false` to turn off this behavior.
+         */
+        this.showOnlineIndicator = true;
+        this.context = {
+            name: undefined,
+            imageUrl: undefined,
+            size: undefined,
+            location: undefined,
+            channel: undefined,
+            user: undefined,
+            type: undefined,
+            initialsType: undefined,
+            showOnlineIndicator: undefined,
+        };
+    }
+    ngOnChanges() {
+        this.context = {
+            name: this.name,
+            imageUrl: this.imageUrl,
+            size: this.size,
+            location: this.location,
+            type: this.type,
+            user: this.user,
+            channel: this.channel,
+            initialsType: this.initialsType,
+            showOnlineIndicator: this.showOnlineIndicator,
+        };
+    }
+}
+AvatarPlaceholderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AvatarPlaceholderComponent, deps: [{ token: i1.CustomTemplatesService }], target: i0.ɵɵFactoryTarget.Component });
+AvatarPlaceholderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: AvatarPlaceholderComponent, selector: "stream-avatar-placeholder", inputs: { name: "name", imageUrl: "imageUrl", size: "size", location: "location", channel: "channel", user: "user", type: "type", initialsType: "initialsType", showOnlineIndicator: "showOnlineIndicator" }, usesOnChanges: true, ngImport: i0, template: "<ng-template\n  #defaultAvatar\n  let-name=\"name\"\n  let-imageUrl=\"imageUrl\"\n  let-size=\"size\"\n  let-type=\"type\"\n  let-channel=\"channel\"\n  let-user=\"user\"\n  let-location=\"location\"\n  let-initialsType=\"initialsType\"\n  let-showOnlineIndicator=\"showOnlineIndicator\"\n>\n  <stream-avatar\n    [name]=\"name\"\n    [imageUrl]=\"imageUrl\"\n    [size]=\"size\"\n    [type]=\"type\"\n    [channel]=\"channel\"\n    [user]=\"user\"\n    [location]=\"location\"\n    [initialsType]=\"initialsType\"\n    [showOnlineIndicator]=\"showOnlineIndicator\"\n  ></stream-avatar>\n</ng-template>\n<ng-container\n  *ngTemplateOutlet=\"\n    (customTemplatesService.avatarTemplate$ | async) || defaultAvatar;\n    context: context\n  \"\n></ng-container>\n", dependencies: [{ kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i3.AvatarComponent, selector: "stream-avatar", inputs: ["name", "imageUrl", "size", "location", "channel", "user", "type", "showOnlineIndicator", "initialsType"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AvatarPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'stream-avatar-placeholder', template: "<ng-template\n  #defaultAvatar\n  let-name=\"name\"\n  let-imageUrl=\"imageUrl\"\n  let-size=\"size\"\n  let-type=\"type\"\n  let-channel=\"channel\"\n  let-user=\"user\"\n  let-location=\"location\"\n  let-initialsType=\"initialsType\"\n  let-showOnlineIndicator=\"showOnlineIndicator\"\n>\n  <stream-avatar\n    [name]=\"name\"\n    [imageUrl]=\"imageUrl\"\n    [size]=\"size\"\n    [type]=\"type\"\n    [channel]=\"channel\"\n    [user]=\"user\"\n    [location]=\"location\"\n    [initialsType]=\"initialsType\"\n    [showOnlineIndicator]=\"showOnlineIndicator\"\n  ></stream-avatar>\n</ng-template>\n<ng-container\n  *ngTemplateOutlet=\"\n    (customTemplatesService.avatarTemplate$ | async) || defaultAvatar;\n    context: context\n  \"\n></ng-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.CustomTemplatesService }]; }, propDecorators: { name: [{
+                type: Input
+            }], imageUrl: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], location: [{
+                type: Input
+            }], channel: [{
+                type: Input
+            }], user: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], initialsType: [{
+                type: Input
+            }], showOnlineIndicator: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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