stream-chat-angular 6.0.0-beta.5 → 6.0.0-rc.2

package/esm2020/lib/chat-client.service.mjs

@@ -0,0 +1,233 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import { StreamChat } from 'stream-chat';
+import { version } from '../assets/version';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./notification.service";
+/**
+ * The `ChatClient` service connects the user to the Stream chat.
+ */
+export class ChatClientService {
+    constructor(ngZone, notificationService) {
+        this.ngZone = ngZone;
+        this.notificationService = notificationService;
+        this.notificationSubject = new ReplaySubject(1);
+        this.connectionStateSubject = new ReplaySubject(1);
+        this.appSettingsSubject = new BehaviorSubject(undefined);
+        this.pendingInvitesSubject = new BehaviorSubject([]);
+        this.userSubject = new ReplaySubject(1);
+        this.subscriptions = [];
+        this.trackPendingChannelInvites = true;
+        this.events$ = this.notificationSubject.asObservable();
+        this.connectionState$ = this.connectionStateSubject.asObservable();
+        this.appSettings$ = this.appSettingsSubject.asObservable();
+        this.pendingInvites$ = this.pendingInvitesSubject.asObservable();
+        this.user$ = this.userSubject.asObservable();
+    }
+    /**
+     * Creates a [`StreamChat`](https://github.com/GetStream/stream-chat-js/blob/668b3e5521339f4e14fc657834531b4c8bf8176b/src/client.ts#L124) instance using the provided `apiKey`, and connects a user with the given meta data and token. More info about [connecting users](/chat/docs/javascript/init_and_users/) can be found in the platform documentation.
+     * @param apiKey
+     * @param userOrId you can emit this for anonymous logins
+     * @param userTokenOrProvider You can provide:<ul>
+     *  <li> a token, </li>
+     *  <li> a token provider, a method that returns `Promise<string>`, which can be called when the previous token expires (recommended setup for production applications)</li>
+     *  <li> the keyword 'guest' to connect as [guest user](/chat/docs/javascript/authless_users/#guest-users) </li>
+     *  <li> the keyword 'anonymous' to connect as [anonymous user](/chat/docs/javascript/authless_users/#anonymous-users) </li>
+     *  </ul>
+     * @param clientOptions Setting to provide to the Stream client instance
+     */
+    async init(apiKey, userOrId, userTokenOrProvider, clientOptions) {
+        if (this.chatClient && this.chatClient.key !== apiKey) {
+            this.appSettingsSubject.next(undefined);
+            this.appSettingsPromise = undefined;
+        }
+        this.trackPendingChannelInvites =
+            clientOptions?.trackPendingChannelInvites === true;
+        this.chatClient = StreamChat.getInstance(apiKey, clientOptions);
+        this.chatClient.sdkIdentifier = {
+            name: 'angular',
+            version,
+        };
+        this.chatClient.recoverStateOnReconnect = false;
+        this.chatClient.devToken;
+        let result;
+        await this.ngZone.runOutsideAngular(async () => {
+            const user = typeof userOrId === 'string' ? { id: userOrId } : userOrId;
+            try {
+                result = await ({
+                    guest: () => this.chatClient.setGuestUser(user),
+                    anonymous: () => this.chatClient.connectAnonymousUser(),
+                    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                }[`${userTokenOrProvider}`] ??
+                    (() => this.chatClient.connectUser(user, userTokenOrProvider)))();
+            }
+            catch (error) {
+                this.notificationService.addPermanentNotification('streamChat.Error connecting to chat, refresh the page to try again.', 'error');
+                throw error;
+            }
+            this.userSubject.next(this.chatClient.user ? { ...this.chatClient.user } : undefined);
+        });
+        if (this.chatClient.user?.id && this.trackPendingChannelInvites) {
+            const channels = await this.chatClient.queryChannels({
+                invite: 'pending',
+                members: { $in: [this.chatClient.user?.id] },
+            } // TODO: find out why we need this typecast
+            );
+            this.pendingInvitesSubject.next(channels);
+        }
+        this.subscriptions.push(this.chatClient.on((e) => {
+            this.updateUser(e);
+            this.updatePendingInvites(e);
+            this.notificationSubject.next({
+                eventType: e.type,
+                event: e,
+            });
+        }));
+        let removeNotification;
+        this.subscriptions.push(this.chatClient.on('connection.changed', (e) => {
+            this.ngZone.run(() => {
+                const isOnline = e.online;
+                if (isOnline) {
+                    if (removeNotification) {
+                        removeNotification();
+                    }
+                }
+                else {
+                    removeNotification =
+                        this.notificationService.addPermanentNotification('streamChat.Connection failure, reconnecting now...');
+                }
+                this.connectionStateSubject.next(isOnline ? 'online' : 'offline');
+            });
+        }));
+        return result;
+    }
+    /**
+     * Disconnects the current user, and closes the WebSocket connection. Useful when disconnecting a chat user, use in combination with [`reset`](/chat/docs/sdk/angular/v6-rc/services/ChannelService/#reset/).
+     */
+    async disconnectUser() {
+        this.pendingInvitesSubject.next([]);
+        await this.chatClient.disconnectUser();
+        this.userSubject.next(undefined);
+        this.subscriptions.forEach((s) => s.unsubscribe());
+    }
+    /**
+     * Loads the current [application settings](/chat/docs/javascript/app_setting_overview/), if the application settings have already been loaded, it does nothing.
+     */
+    async getAppSettings() {
+        if (this.appSettingsPromise) {
+            return;
+        }
+        if (this.appSettingsSubject.getValue()) {
+            return;
+        }
+        this.appSettingsPromise = this.chatClient.getAppSettings();
+        void this.appSettingsPromise.finally(() => {
+            this.appSettingsPromise = undefined;
+        });
+        const settings = await this.appSettingsPromise;
+        this.appSettingsSubject.next(settings.app || {});
+    }
+    /**
+     * Flag the message with the given ID. If you want to know [more about flags](/chat/docs/javascript/moderation/) check out the platform documentation.
+     * @param messageId
+     */
+    async flagMessage(messageId) {
+        await this.chatClient.flagMessage(messageId);
+    }
+    /**
+     * Searches for users in the application that have ID or name matching the provided search term
+     * @param searchTerm
+     * @returns The users matching the search
+     */
+    async autocompleteUsers(searchTerm) {
+        if (!searchTerm) {
+            return [];
+        }
+        const result = await this.chatClient.queryUsers({
+            $or: [
+                { id: { $autocomplete: searchTerm } },
+                { name: { $autocomplete: searchTerm } },
+            ],
+        }); // TODO: find out why we need this typecast
+        return result.users.filter((u) => u.id !== this.chatClient?.user?.id);
+    }
+    updatePendingInvites(e) {
+        if (!this.trackPendingChannelInvites) {
+            return;
+        }
+        if (e.member?.user?.id === this.chatClient.user?.id && e.channel) {
+            const pendingInvites = this.pendingInvitesSubject.getValue();
+            if (e.type === 'notification.invited') {
+                const channel = this.chatClient.channel(e.channel?.type, e.channel?.id);
+                this.pendingInvitesSubject.next([...pendingInvites, channel]);
+            }
+            else if (e.type === 'notification.invite_accepted' ||
+                e.type === 'notification.invite_rejected') {
+                const index = pendingInvites.findIndex((i) => i?.cid === e.channel?.cid);
+                if (index !== -1) {
+                    pendingInvites.splice(index, 1);
+                    this.pendingInvitesSubject.next([...pendingInvites]);
+                }
+            }
+        }
+    }
+    updateUser(e) {
+        if (typeof e.total_unread_count !== 'undefined') {
+            let user;
+            this.userSubject.pipe(take(1)).subscribe((u) => {
+                user = u;
+            });
+            if (user &&
+                'total_unread_count' in user &&
+                user.total_unread_count !== e.total_unread_count) {
+                this.userSubject.next({
+                    ...user,
+                    total_unread_count: e.total_unread_count,
+                });
+            }
+        }
+        if (typeof e.unread_channels !== 'undefined') {
+            let user;
+            this.userSubject.pipe(take(1)).subscribe((u) => {
+                user = u;
+            });
+            if (user &&
+                'unread_channels' in user &&
+                user.unread_channels !== e.unread_channels) {
+                this.userSubject.next({
+                    ...user,
+                    unread_channels: e.unread_channels,
+                });
+            }
+        }
+        if (typeof e.unread_count !== 'undefined') {
+            let user;
+            this.userSubject.pipe(take(1)).subscribe((u) => {
+                user = u;
+            });
+            if (user &&
+                'unread_count' in user &&
+                user.unread_count !== e.unread_count) {
+                this.userSubject.next({
+                    ...user,
+                    unread_count: e.unread_count,
+                });
+            }
+        }
+        if (e.type === 'user.updated' &&
+            this.chatClient.user &&
+            e.user?.id === this.chatClient.user.id) {
+            this.userSubject.next({ ...this.chatClient.user });
+        }
+    }
+}
+ChatClientService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: ChatClientService, deps: [{ token: i0.NgZone }, { token: i1.NotificationService }], target: i0.ɵɵFactoryTarget.Injectable });
+ChatClientService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: ChatClientService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: ChatClientService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.NotificationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat-client.service.js","sourceRoot":"","sources":["../../../../projects/stream-chat-angular/src/lib/chat-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';\nimport {\n  AppSettingsAPIResponse,\n  Channel,\n  ChannelFilters,\n  ConnectAPIResponse,\n  OwnUserResponse,\n  StreamChatOptions,\n  UserFilters,\n  UserResponse,\n} from 'stream-chat';\nimport { AppSettings, Event, StreamChat, TokenOrProvider } from 'stream-chat';\nimport { version } from '../assets/version';\nimport { NotificationService } from './notification.service';\nimport { take } from 'rxjs/operators';\n\nexport type ClientEvent = {\n  eventType: string;\n  event: Event;\n};\n\n/**\n * The `ChatClient` service connects the user to the Stream chat.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ChatClientService {\n  /**\n   * The [StreamChat client](https://github.com/GetStream/stream-chat-js/blob/master/src/client.ts) instance. In general you shouldn't need to access the client, but it's there if you want to use it.\n   */\n  chatClient!: StreamChat;\n  /**\n   * Emits [`ClientEvent`](https://github.com/GetStream/stream-chat-angular/blob/master/projects/stream-chat-angular/src/lib/chat-client.service.ts) events. The platform documentation covers [the list of client, user presence and notification events](/chat/docs/javascript/event_object/).\n   * :::important\n   * For performance reasons this Observable operates outside of the Angular change detection zone. If you subscribe to it, you need to manually reenter Angular's change detection zone, our [Change detection guide](/chat/docs/sdk/angular/v6-rc/concepts/change-detection/) explains this in detail.\n   * :::\n   */\n  events$: Observable<ClientEvent>;\n  /**\n   * Emits the current [application settings](/chat/docs/javascript/app_setting_overview/). Since getting the application settings is an expensive API call and we don't always need the result, this is not initialized by default, you need to call `getApplicationSettings` to load them.\n   */\n  appSettings$: Observable<AppSettings | undefined>;\n  /**\n   * Emits the current connection state of the user (`online` or `offline`)\n   */\n  connectionState$: Observable<'offline' | 'online'>;\n  /**\n   * Emits the list of pending invites of the user. It emits every pending invitation during initialization and then extends the list when a new invite is received. More information can be found in the [channel invitations](/chat/docs/sdk/angular/v6-rc/code-examples/channel-invites/) guide.\n   */\n  pendingInvites$: Observable<Channel[]>;\n  /**\n   * Emits the current chat user\n   */\n  user$: Observable<OwnUserResponse | UserResponse | undefined>;\n  private notificationSubject = new ReplaySubject<ClientEvent>(1);\n  private connectionStateSubject = new ReplaySubject<'offline' | 'online'>(1);\n  private appSettingsSubject = new BehaviorSubject<AppSettings | undefined>(\n    undefined\n  );\n  private pendingInvitesSubject = new BehaviorSubject<Channel[]>([]);\n  private userSubject = new ReplaySubject<\n    OwnUserResponse | UserResponse | undefined\n  >(1);\n  private subscriptions: { unsubscribe: () => void }[] = [];\n  private trackPendingChannelInvites = true;\n  private appSettingsPromise?: Promise<AppSettingsAPIResponse>;\n\n  constructor(\n    private ngZone: NgZone,\n    private notificationService: NotificationService\n  ) {\n    this.events$ = this.notificationSubject.asObservable();\n    this.connectionState$ = this.connectionStateSubject.asObservable();\n    this.appSettings$ = this.appSettingsSubject.asObservable();\n    this.pendingInvites$ = this.pendingInvitesSubject.asObservable();\n    this.user$ = this.userSubject.asObservable();\n  }\n\n  /**\n   * Creates a [`StreamChat`](https://github.com/GetStream/stream-chat-js/blob/668b3e5521339f4e14fc657834531b4c8bf8176b/src/client.ts#L124) instance using the provided `apiKey`, and connects a user with the given meta data and token. More info about [connecting users](/chat/docs/javascript/init_and_users/) can be found in the platform documentation.\n   * @param apiKey\n   * @param userOrId you can emit this for anonymous logins\n   * @param userTokenOrProvider You can provide:<ul>\n   *  <li> a token, </li>\n   *  <li> a token provider, a method that returns `Promise<string>`, which can be called when the previous token expires (recommended setup for production applications)</li>\n   *  <li> the keyword 'guest' to connect as [guest user](/chat/docs/javascript/authless_users/#guest-users) </li>\n   *  <li> the keyword 'anonymous' to connect as [anonymous user](/chat/docs/javascript/authless_users/#anonymous-users) </li>\n   *  </ul>\n   * @param clientOptions Setting to provide to the Stream client instance\n   */\n  async init(\n    apiKey: string,\n    userOrId: string | OwnUserResponse | UserResponse | undefined,\n    userTokenOrProvider: TokenOrProvider,\n    clientOptions?: StreamChatOptions & {\n      trackPendingChannelInvites?: boolean;\n    }\n  ): ConnectAPIResponse {\n    if (this.chatClient && this.chatClient.key !== apiKey) {\n      this.appSettingsSubject.next(undefined);\n      this.appSettingsPromise = undefined;\n    }\n    this.trackPendingChannelInvites =\n      clientOptions?.trackPendingChannelInvites === true;\n    this.chatClient = StreamChat.getInstance(apiKey, clientOptions);\n    this.chatClient.sdkIdentifier = {\n      name: 'angular',\n      version,\n    };\n    this.chatClient.recoverStateOnReconnect = false;\n    this.chatClient.devToken;\n    let result;\n    await this.ngZone.runOutsideAngular(async () => {\n      const user = typeof userOrId === 'string' ? { id: userOrId } : userOrId;\n      try {\n        result = await (\n          {\n            guest: () => this.chatClient.setGuestUser(user!),\n            anonymous: () => this.chatClient.connectAnonymousUser(),\n            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n          }[`${userTokenOrProvider}`] ??\n          (() => this.chatClient.connectUser(user!, userTokenOrProvider))\n        )();\n      } catch (error) {\n        this.notificationService.addPermanentNotification(\n          'streamChat.Error connecting to chat, refresh the page to try again.',\n          'error'\n        );\n        throw error;\n      }\n      this.userSubject.next(\n        this.chatClient.user ? { ...this.chatClient.user } : undefined\n      );\n    });\n    if (this.chatClient.user?.id && this.trackPendingChannelInvites) {\n      const channels = await this.chatClient.queryChannels(\n        {\n          invite: 'pending',\n          members: { $in: [this.chatClient.user?.id] },\n        } as unknown as ChannelFilters // TODO: find out why we need this typecast\n      );\n      this.pendingInvitesSubject.next(channels);\n    }\n    this.subscriptions.push(\n      this.chatClient.on((e) => {\n        this.updateUser(e);\n        this.updatePendingInvites(e);\n        this.notificationSubject.next({\n          eventType: e.type,\n          event: e,\n        });\n      })\n    );\n    let removeNotification: undefined | (() => void);\n    this.subscriptions.push(\n      this.chatClient.on('connection.changed', (e) => {\n        this.ngZone.run(() => {\n          const isOnline = e.online;\n          if (isOnline) {\n            if (removeNotification) {\n              removeNotification();\n            }\n          } else {\n            removeNotification =\n              this.notificationService.addPermanentNotification(\n                'streamChat.Connection failure, reconnecting now...'\n              );\n          }\n          this.connectionStateSubject.next(isOnline ? 'online' : 'offline');\n        });\n      })\n    );\n    return result;\n  }\n\n  /**\n   * Disconnects the current user, and closes the WebSocket connection. Useful when disconnecting a chat user, use in combination with [`reset`](/chat/docs/sdk/angular/v6-rc/services/ChannelService/#reset/).\n   */\n  async disconnectUser() {\n    this.pendingInvitesSubject.next([]);\n    await this.chatClient.disconnectUser();\n    this.userSubject.next(undefined);\n    this.subscriptions.forEach((s) => s.unsubscribe());\n  }\n\n  /**\n   * Loads the current [application settings](/chat/docs/javascript/app_setting_overview/), if the application settings have already been loaded, it does nothing.\n   */\n  async getAppSettings() {\n    if (this.appSettingsPromise) {\n      return;\n    }\n    if (this.appSettingsSubject.getValue()) {\n      return;\n    }\n    this.appSettingsPromise = this.chatClient.getAppSettings();\n    void this.appSettingsPromise.finally(() => {\n      this.appSettingsPromise = undefined;\n    });\n    const settings = await this.appSettingsPromise;\n    this.appSettingsSubject.next((settings.app as AppSettings) || {});\n  }\n\n  /**\n   * Flag the message with the given ID. If you want to know [more about flags](/chat/docs/javascript/moderation/) check out the platform documentation.\n   * @param messageId\n   */\n  async flagMessage(messageId: string) {\n    await this.chatClient.flagMessage(messageId);\n  }\n\n  /**\n   * Searches for users in the application that have ID or name matching the provided search term\n   * @param searchTerm\n   * @returns The users matching the search\n   */\n  async autocompleteUsers(searchTerm: string) {\n    if (!searchTerm) {\n      return [];\n    }\n    const result = await this.chatClient.queryUsers({\n      $or: [\n        { id: { $autocomplete: searchTerm } },\n        { name: { $autocomplete: searchTerm } },\n      ],\n    } as UserFilters); // TODO: find out why we need this typecast\n    return result.users.filter((u) => u.id !== this.chatClient?.user?.id);\n  }\n\n  private updatePendingInvites(e: Event) {\n    if (!this.trackPendingChannelInvites) {\n      return;\n    }\n    if (e.member?.user?.id === this.chatClient.user?.id && e.channel) {\n      const pendingInvites = this.pendingInvitesSubject.getValue();\n      if (e.type === 'notification.invited') {\n        const channel = this.chatClient.channel(e.channel?.type, e.channel?.id);\n        this.pendingInvitesSubject.next([...pendingInvites, channel]);\n      } else if (\n        e.type === 'notification.invite_accepted' ||\n        e.type === 'notification.invite_rejected'\n      ) {\n        const index = pendingInvites.findIndex(\n          (i) => i?.cid === e.channel?.cid\n        );\n        if (index !== -1) {\n          pendingInvites.splice(index, 1);\n          this.pendingInvitesSubject.next([...pendingInvites]);\n        }\n      }\n    }\n  }\n\n  private updateUser(e: Event) {\n    if (typeof e.total_unread_count !== 'undefined') {\n      let user: OwnUserResponse | UserResponse | undefined;\n      this.userSubject.pipe(take(1)).subscribe((u) => {\n        user = u;\n      });\n      if (\n        user &&\n        'total_unread_count' in user &&\n        user.total_unread_count !== e.total_unread_count\n      ) {\n        this.userSubject.next({\n          ...user,\n          total_unread_count: e.total_unread_count,\n        });\n      }\n    }\n    if (typeof e.unread_channels !== 'undefined') {\n      let user: OwnUserResponse | UserResponse | undefined;\n      this.userSubject.pipe(take(1)).subscribe((u) => {\n        user = u;\n      });\n      if (\n        user &&\n        'unread_channels' in user &&\n        user.unread_channels !== e.unread_channels\n      ) {\n        this.userSubject.next({\n          ...user,\n          unread_channels: e.unread_channels,\n        });\n      }\n    }\n    if (typeof e.unread_count !== 'undefined') {\n      let user: OwnUserResponse | UserResponse | undefined;\n      this.userSubject.pipe(take(1)).subscribe((u) => {\n        user = u;\n      });\n      if (\n        user &&\n        'unread_count' in user &&\n        user.unread_count !== e.unread_count\n      ) {\n        this.userSubject.next({\n          ...user,\n          unread_count: e.unread_count,\n        });\n      }\n    }\n    if (\n      e.type === 'user.updated' &&\n      this.chatClient.user &&\n      e.user?.id === this.chatClient.user.id\n    ) {\n      this.userSubject.next({ ...this.chatClient.user });\n    }\n  }\n}\n"]}

package/esm2020/lib/custom-templates.service.mjs

@@ -0,0 +1,244 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * A central location for registering your custom templates to override parts of the chat application.
+ *
+ * For code examples to the different customizations see our [customizations example application](https://github.com/GetStream/stream-chat-angular/tree/master/projects/customizations-example), specifically the [AppComponent](https://github.com/GetStream/stream-chat-angular/tree/master/projects/customizations-example/src/app) (see [README](https://github.com/GetStream/stream-chat-angular/blob/master/README.md#customization-examples) for instructions on how to start the application).
+ *
+ * You can find the type definitions of the context that is provided for each template [on GitHub](https://github.com/GetStream/stream-chat-angular/blob/master/projects/stream-chat-angular/src/lib/types.ts)
+ */
+export class CustomTemplatesService {
+    constructor() {
+        /**
+         * The autocomplete list item template for mentioning users (used in the [`AutocompleteTextareaComponent`](/chat/docs/sdk/angular/v6-rc/components/AutocompleteTextareaComponent/))
+         */
+        this.mentionAutocompleteItemTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The autocomplete list item template for commands (used in the [`AutocompleteTextareaComponent`](/chat/docs/sdk/angular/v6-rc/components/AutocompleteTextareaComponent/))
+         */
+        this.commandAutocompleteItemTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * Template used to display an item in the [channel list](/chat/docs/sdk/angular/v6-rc/components/ChannelListComponent/) (instead of the default [channal list item](/chat/docs/sdk/angular/v6-rc/components/ChannelPreviewComponent/))
+         *
+         */
+        this.channelPreviewTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used for displaying a [mention inside a message](/chat/docs/sdk/angular/v6-rc/code-examples/mention-actions/)
+         *
+         */
+        this.mentionTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template for [emoji picker](/chat/docs/sdk/angular/v6-rc/code-examples/emoji-picker)
+         *
+         */
+        this.emojiPickerTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The typing indicator template used in the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/)
+         *
+         */
+        this.typingIndicatorTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display a message in the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/) (instead of the [default message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/))
+         *
+         */
+        this.messageTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template for channel actions displayed in the [channel header](/chat/docs/sdk/angular/v6-rc/components/ChannelHeaderComponent/) (by default no channel action is displayed)
+         *
+         */
+        this.channelActionsTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display attachments of a [message](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/) (instead of the [default attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/))
+         *
+         */
+        this.attachmentListTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display attachments in the [message input](/chat/docs/sdk/angular/v6-rc/components/MessageInputComponent) component (instead of the [default attachment preview](/chat/docs/sdk/angular/v6-rc/components/AttachmentPreviewListComponent))
+         *
+         */
+        this.attachmentPreviewListTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display avatars for channels and users (instead of the [default avatar](/chat/docs/sdk/angular/v6-rc/components/AvatarComponent/))
+         *
+         */
+        this.avatarTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * Template for displaying icons (instead of the [default icon component](/chat/docs/sdk/angular/v6-rc/components/IconComponent/))
+         *
+         */
+        this.iconTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * Template for displaying the loading indicator (instead of the [default loading indicator](/chat/docs/sdk/angular/v6-rc/components/LoadingIndicatorComponent/))
+         *
+         */
+        this.loadingIndicatorTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * Template for displaying the message actions box (instead of the [default message actions box](/chat/docs/sdk/angular/v6-rc/components/MessageActionsBoxComponent/))
+         *
+         */
+        this.messageActionsBoxTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used for displaying an item in the [message actions box](/chat/docs/sdk/angular/v6-rc/components/MessageActionsBoxComponent/)
+         *
+         */
+        this.messageActionsBoxItemTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display the reactions of a [message](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/), and the selector to add a reaction to a message (instead of the [default message reactions component](/chat/docs/sdk/angular/v6-rc/components/MessageReactionsComponent/))
+         *
+         */
+        this.messageReactionsTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display the reactions of a [message](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/), and the selector to add a reaction to a message (instead of the [default message reactions component](/chat/docs/sdk/angular/v6-rc/components/MessageReactionsComponent/))
+         *
+         */
+        this.messageReactionsSelectorTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display a modal window (instead of the [default modal](/chat/docs/sdk/angular/v6-rc/components/ModalComponent/))
+         *
+         */
+        this.modalTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to override the [default notification component](/chat/docs/sdk/angular/v6-rc/components/NotificationComponent/)
+         *
+         */
+        this.notificationTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used for header of a [thread](/chat/docs/sdk/angular/v6-rc/components/ThreadComponent/)
+         *
+         */
+        this.threadHeaderTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used for displaying the delivered state of the message inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         *
+         * Displayed for the last message sent by the current user, if the message isn't yet read by anyone
+         *
+         */
+        this.deliveredStatusTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used for displaying the sending state of the message inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         *
+         * Displayed for the last message sent by the current user, if the message is currently being sent
+         *
+         */
+        this.sendingStatusTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used for displaying the sent state of the message inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         *
+         * Displayed for the last message sent by the current user, if the message is read at least by one user
+         *
+         */
+        this.readStatusTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * Template to display custom metadata inside [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         *
+         */
+        this.customMessageMetadataTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display additional information about a channel under the channel name inside the [channel header component](/chat/docs/sdk/angular/v6-rc/components/ChannelHeaderComponent/)
+         *
+         */
+        this.channelHeaderInfoTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used for displaying file upload/attachment selector inside the [message input](/chat/docs/sdk/angular/v6-rc/components/MessageInputComponent/)
+         *
+         */
+        this.customAttachmentUploadTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template that can be used to override how a single image attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)
+         */
+        this.imageAttachmentTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template that can be used to override how a voice recording attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/), by default the [voice recording component](/chat/docs/sdk/angular/v6-rc/components/VoiceRecordingComponent/) is used
+         */
+        this.voiceRecordingAttachmentTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template that can be used to override how a video attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)
+         */
+        this.videoAttachmentTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template that can be used to override how image gallery is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)
+         */
+        this.galleryAttachmentTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template that can be used to override how a file attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)
+         */
+        this.fileAttachmentTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template that can be used to override how a card attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)
+         */
+        this.cardAttachmentTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template that can be used to override how attachment actions are displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)
+         */
+        this.attachmentActionsTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display [system messages](/chat/docs/javascript/silent_messages/) indise the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         */
+        this.systemMessageTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display the date separator inside the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/)
+         */
+        this.dateSeparatorTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display unread messages indicator inside the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/) when the channel is opened
+         *
+         * This UI element is used to separate unread messages from read messages
+         */
+        this.newMessagesIndicatorTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display unread messages notification inside the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/) when the channel is opened
+         *
+         * Users can use this notification to jump to the first unread message when it's clicked
+         */
+        this.newMessagesNotificationTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template to show if the main message list is empty
+         */
+        this.emptyMainMessageListPlaceholder$ = new BehaviorSubject(undefined);
+        /**
+         * The template to show if the thread message list is empty
+         */
+        this.emptyThreadMessageListPlaceholder$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display the [message bounce prompt](/chat/docs/sdk/angular/v6-rc/components/MessageBouncePromptComponent/)
+         */
+        this.messageBouncePromptTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * Template used to display the channel information inside the [channel list item](/chat/docs/sdk/angular/v6-rc/components/ChannelPreviewComponent/)
+         *
+         */
+        this.channelPreviewInfoTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display custom attachment previews in the [message input component](/chat/docs/sdk/angular/v6-rc/components/MessageInputComponent/)
+         */
+        this.customAttachmentPreviewListTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display custom attachments in the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         */
+        this.customAttachmentListTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * The template used to display the number of thread replies inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         */
+        this.threadLinkButton$ = new BehaviorSubject(undefined);
+        /**
+         * Template to display custom metadata inside the message bubble of the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)
+         *
+         * To properly position your template you should override the `grid-template-areas` of the `.str-chat__message-inner` selector
+         */
+        this.customMessageMetadataInsideBubbleTemplate$ = new BehaviorSubject(undefined);
+        /**
+         * Template to display the text content inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/). The default component is [stream-message-text](/chat/docs/sdk/angular/v6-rc/components/MessageTextComponent/)
+         */
+        this.messageTextTemplate$ = new BehaviorSubject(undefined);
+    }
+}
+CustomTemplatesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: CustomTemplatesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CustomTemplatesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: CustomTemplatesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: CustomTemplatesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-templates.service.js","sourceRoot":"","sources":["../../../../projects/stream-chat-angular/src/lib/custom-templates.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, TemplateRef } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport {\n  AttachmentContext,\n  AttachmentListContext,\n  AttachmentPreviewListContext,\n  AvatarContext,\n  ChannelActionsContext,\n  ChannelHeaderInfoContext,\n  ChannelPreviewContext,\n  ChannelPreviewInfoContext,\n  CommandAutocompleteListItemContext,\n  CustomAttachmentListContext,\n  CustomAttachmentPreviewListContext,\n  CustomAttachmentUploadContext,\n  CustomMetadataContext,\n  DateSeparatorContext,\n  DeliveredStatusContext,\n  EmojiPickerContext,\n  GalleryAttachmentContext,\n  IconContext,\n  MentionAutcompleteListItemContext,\n  MentionTemplateContext,\n  MessageActionBoxItemContext,\n  MessageActionsBoxContext,\n  MessageContext,\n  MessageReactionsContext,\n  MessageReactionsSelectorContext,\n  MessageTextContext,\n  ModalContext,\n  NotificationContext,\n  ReadStatusContext,\n  SendingStatusContext,\n  SystemMessageContext,\n  ThreadHeaderContext,\n  ThreadReplyButtonContext,\n  TypingIndicatorContext,\n  UnreadMessagesIndicatorContext,\n  UnreadMessagesNotificationContext,\n} from './types';\n\n/**\n * A central location for registering your custom templates to override parts of the chat application.\n *\n * For code examples to the different customizations see our [customizations example application](https://github.com/GetStream/stream-chat-angular/tree/master/projects/customizations-example), specifically the [AppComponent](https://github.com/GetStream/stream-chat-angular/tree/master/projects/customizations-example/src/app) (see [README](https://github.com/GetStream/stream-chat-angular/blob/master/README.md#customization-examples) for instructions on how to start the application).\n *\n * You can find the type definitions of the context that is provided for each template [on GitHub](https://github.com/GetStream/stream-chat-angular/blob/master/projects/stream-chat-angular/src/lib/types.ts)\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class CustomTemplatesService {\n  /**\n   * The autocomplete list item template for mentioning users (used in the [`AutocompleteTextareaComponent`](/chat/docs/sdk/angular/v6-rc/components/AutocompleteTextareaComponent/))\n   */\n  mentionAutocompleteItemTemplate$ = new BehaviorSubject<\n    TemplateRef<MentionAutcompleteListItemContext> | undefined\n  >(undefined);\n  /**\n   * The autocomplete list item template for commands (used in the [`AutocompleteTextareaComponent`](/chat/docs/sdk/angular/v6-rc/components/AutocompleteTextareaComponent/))\n   */\n  commandAutocompleteItemTemplate$ = new BehaviorSubject<\n    TemplateRef<CommandAutocompleteListItemContext> | undefined\n  >(undefined);\n  /**\n   * Template used to display an item in the [channel list](/chat/docs/sdk/angular/v6-rc/components/ChannelListComponent/) (instead of the default [channal list item](/chat/docs/sdk/angular/v6-rc/components/ChannelPreviewComponent/))\n   *\n   */\n  channelPreviewTemplate$ = new BehaviorSubject<\n    TemplateRef<ChannelPreviewContext> | undefined\n  >(undefined);\n  /**\n   * The template used for displaying a [mention inside a message](/chat/docs/sdk/angular/v6-rc/code-examples/mention-actions/)\n   *\n   */\n  mentionTemplate$ = new BehaviorSubject<\n    TemplateRef<MentionTemplateContext> | undefined\n  >(undefined);\n  /**\n   * The template for [emoji picker](/chat/docs/sdk/angular/v6-rc/code-examples/emoji-picker)\n   *\n   */\n  emojiPickerTemplate$ = new BehaviorSubject<\n    TemplateRef<EmojiPickerContext> | undefined\n  >(undefined);\n  /**\n   * The typing indicator template used in the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/)\n   *\n   */\n  typingIndicatorTemplate$ = new BehaviorSubject<\n    TemplateRef<TypingIndicatorContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display a message in the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/) (instead of the [default message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/))\n   *\n   */\n  messageTemplate$ = new BehaviorSubject<\n    TemplateRef<MessageContext> | undefined\n  >(undefined);\n  /**\n   * The template for channel actions displayed in the [channel header](/chat/docs/sdk/angular/v6-rc/components/ChannelHeaderComponent/) (by default no channel action is displayed)\n   *\n   */\n  channelActionsTemplate$ = new BehaviorSubject<\n    TemplateRef<ChannelActionsContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display attachments of a [message](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/) (instead of the [default attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/))\n   *\n   */\n  attachmentListTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentListContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display attachments in the [message input](/chat/docs/sdk/angular/v6-rc/components/MessageInputComponent) component (instead of the [default attachment preview](/chat/docs/sdk/angular/v6-rc/components/AttachmentPreviewListComponent))\n   *\n   */\n  attachmentPreviewListTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentPreviewListContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display avatars for channels and users (instead of the [default avatar](/chat/docs/sdk/angular/v6-rc/components/AvatarComponent/))\n   *\n   */\n  avatarTemplate$ = new BehaviorSubject<TemplateRef<AvatarContext> | undefined>(\n    undefined\n  );\n  /**\n   * Template for displaying icons (instead of the [default icon component](/chat/docs/sdk/angular/v6-rc/components/IconComponent/))\n   *\n   */\n  iconTemplate$ = new BehaviorSubject<TemplateRef<IconContext> | undefined>(\n    undefined\n  );\n  /**\n   * Template for displaying the loading indicator (instead of the [default loading indicator](/chat/docs/sdk/angular/v6-rc/components/LoadingIndicatorComponent/))\n   *\n   */\n  loadingIndicatorTemplate$ = new BehaviorSubject<\n    TemplateRef<void> | undefined\n  >(undefined);\n  /**\n   * Template for displaying the message actions box (instead of the [default message actions box](/chat/docs/sdk/angular/v6-rc/components/MessageActionsBoxComponent/))\n   *\n   */\n  messageActionsBoxTemplate$ = new BehaviorSubject<\n    TemplateRef<MessageActionsBoxContext> | undefined\n  >(undefined);\n  /**\n   * The template used for displaying an item in the [message actions box](/chat/docs/sdk/angular/v6-rc/components/MessageActionsBoxComponent/)\n   *\n   */\n  messageActionsBoxItemTemplate$ = new BehaviorSubject<\n    TemplateRef<MessageActionBoxItemContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display the reactions of a [message](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/), and the selector to add a reaction to a message (instead of the [default message reactions component](/chat/docs/sdk/angular/v6-rc/components/MessageReactionsComponent/))\n   *\n   */\n  messageReactionsTemplate$ = new BehaviorSubject<\n    TemplateRef<MessageReactionsContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display the reactions of a [message](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/), and the selector to add a reaction to a message (instead of the [default message reactions component](/chat/docs/sdk/angular/v6-rc/components/MessageReactionsComponent/))\n   *\n   */\n  messageReactionsSelectorTemplate$ = new BehaviorSubject<\n    TemplateRef<MessageReactionsSelectorContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display a modal window (instead of the [default modal](/chat/docs/sdk/angular/v6-rc/components/ModalComponent/))\n   *\n   */\n  modalTemplate$ = new BehaviorSubject<TemplateRef<ModalContext> | undefined>(\n    undefined\n  );\n  /**\n   * The template used to override the [default notification component](/chat/docs/sdk/angular/v6-rc/components/NotificationComponent/)\n   *\n   */\n  notificationTemplate$ = new BehaviorSubject<\n    TemplateRef<NotificationContext> | undefined\n  >(undefined);\n  /**\n   * The template used for header of a [thread](/chat/docs/sdk/angular/v6-rc/components/ThreadComponent/)\n   *\n   */\n  threadHeaderTemplate$ = new BehaviorSubject<\n    TemplateRef<ThreadHeaderContext> | undefined\n  >(undefined);\n  /**\n   * The template used for displaying the delivered state of the message inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   *\n   * Displayed for the last message sent by the current user, if the message isn't yet read by anyone\n   *\n   */\n  deliveredStatusTemplate$ = new BehaviorSubject<\n    TemplateRef<DeliveredStatusContext> | undefined\n  >(undefined);\n  /**\n   * The template used for displaying the sending state of the message inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   *\n   * Displayed for the last message sent by the current user, if the message is currently being sent\n   *\n   */\n  sendingStatusTemplate$ = new BehaviorSubject<\n    TemplateRef<SendingStatusContext> | undefined\n  >(undefined);\n  /**\n   * The template used for displaying the sent state of the message inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   *\n   * Displayed for the last message sent by the current user, if the message is read at least by one user\n   *\n   */\n  readStatusTemplate$ = new BehaviorSubject<\n    TemplateRef<ReadStatusContext> | undefined\n  >(undefined);\n  /**\n   * Template to display custom metadata inside [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   *\n   */\n  customMessageMetadataTemplate$ = new BehaviorSubject<\n    TemplateRef<CustomMetadataContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display additional information about a channel under the channel name inside the [channel header component](/chat/docs/sdk/angular/v6-rc/components/ChannelHeaderComponent/)\n   *\n   */\n  channelHeaderInfoTemplate$ = new BehaviorSubject<\n    TemplateRef<ChannelHeaderInfoContext> | undefined\n  >(undefined);\n  /**\n   * The template used for displaying file upload/attachment selector inside the [message input](/chat/docs/sdk/angular/v6-rc/components/MessageInputComponent/)\n   *\n   */\n  customAttachmentUploadTemplate$ = new BehaviorSubject<\n    TemplateRef<CustomAttachmentUploadContext> | undefined\n  >(undefined);\n  /**\n   * The template that can be used to override how a single image attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)\n   */\n  imageAttachmentTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentContext> | undefined\n  >(undefined);\n  /**\n   * The template that can be used to override how a voice recording attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/), by default the [voice recording component](/chat/docs/sdk/angular/v6-rc/components/VoiceRecordingComponent/) is used\n   */\n  voiceRecordingAttachmentTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentContext> | undefined\n  >(undefined);\n  /**\n   * The template that can be used to override how a video attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)\n   */\n  videoAttachmentTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentContext> | undefined\n  >(undefined);\n  /**\n   * The template that can be used to override how image gallery is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)\n   */\n  galleryAttachmentTemplate$ = new BehaviorSubject<\n    TemplateRef<GalleryAttachmentContext> | undefined\n  >(undefined);\n  /**\n   * The template that can be used to override how a file attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)\n   */\n  fileAttachmentTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentContext> | undefined\n  >(undefined);\n  /**\n   * The template that can be used to override how a card attachment is displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)\n   */\n  cardAttachmentTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentContext> | undefined\n  >(undefined);\n  /**\n   * The template that can be used to override how attachment actions are displayed inside the [attachment list](/chat/docs/sdk/angular/v6-rc/components/AttachmentListComponent/)\n   */\n  attachmentActionsTemplate$ = new BehaviorSubject<\n    TemplateRef<AttachmentContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display [system messages](/chat/docs/javascript/silent_messages/) indise the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   */\n  systemMessageTemplate$ = new BehaviorSubject<\n    TemplateRef<SystemMessageContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display the date separator inside the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/)\n   */\n  dateSeparatorTemplate$ = new BehaviorSubject<\n    TemplateRef<DateSeparatorContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display unread messages indicator inside the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/) when the channel is opened\n   *\n   * This UI element is used to separate unread messages from read messages\n   */\n  newMessagesIndicatorTemplate$ = new BehaviorSubject<\n    TemplateRef<UnreadMessagesIndicatorContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display unread messages notification inside the [message list](/chat/docs/sdk/angular/v6-rc/components/MessageListComponent/) when the channel is opened\n   *\n   * Users can use this notification to jump to the first unread message when it's clicked\n   */\n  newMessagesNotificationTemplate$ = new BehaviorSubject<\n    TemplateRef<UnreadMessagesNotificationContext> | undefined\n  >(undefined);\n  /**\n   * The template to show if the main message list is empty\n   */\n  emptyMainMessageListPlaceholder$ = new BehaviorSubject<\n    TemplateRef<void> | undefined\n  >(undefined);\n  /**\n   * The template to show if the thread message list is empty\n   */\n  emptyThreadMessageListPlaceholder$ = new BehaviorSubject<\n    TemplateRef<void> | undefined\n  >(undefined);\n  /**\n   * The template used to display the [message bounce prompt](/chat/docs/sdk/angular/v6-rc/components/MessageBouncePromptComponent/)\n   */\n  messageBouncePromptTemplate$ = new BehaviorSubject<\n    TemplateRef<void> | undefined\n  >(undefined);\n  /**\n   * Template used to display the channel information inside the [channel list item](/chat/docs/sdk/angular/v6-rc/components/ChannelPreviewComponent/)\n   *\n   */\n  channelPreviewInfoTemplate$ = new BehaviorSubject<\n    TemplateRef<ChannelPreviewInfoContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display custom attachment previews in the [message input component](/chat/docs/sdk/angular/v6-rc/components/MessageInputComponent/)\n   */\n  customAttachmentPreviewListTemplate$ = new BehaviorSubject<\n    TemplateRef<CustomAttachmentPreviewListContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display custom attachments in the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   */\n  customAttachmentListTemplate$ = new BehaviorSubject<\n    TemplateRef<CustomAttachmentListContext> | undefined\n  >(undefined);\n  /**\n   * The template used to display the number of thread replies inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   */\n  threadLinkButton$ = new BehaviorSubject<\n    TemplateRef<ThreadReplyButtonContext> | undefined\n  >(undefined);\n  /**\n   * Template to display custom metadata inside the message bubble of the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/)\n   *\n   * To properly position your template you should override the `grid-template-areas` of the `.str-chat__message-inner` selector\n   */\n  customMessageMetadataInsideBubbleTemplate$ = new BehaviorSubject<\n    TemplateRef<CustomMetadataContext> | undefined\n  >(undefined);\n  /**\n   * Template to display the text content inside the [message component](/chat/docs/sdk/angular/v6-rc/components/MessageComponent/). The default component is [stream-message-text](/chat/docs/sdk/angular/v6-rc/components/MessageTextComponent/)\n   */\n  messageTextTemplate$ = new BehaviorSubject<\n    TemplateRef<MessageTextContext> | undefined\n  >(undefined);\n\n  constructor() {}\n}\n"]}

package/{esm2022 → esm2020}/lib/date-parser.service.mjs

@@ -39,13 +39,13 @@ export class DateParserService {
         }
         return parseDate(date, 'date-time');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: DateParserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: DateParserService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: DateParserService, decorators: [{
+DateParserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: DateParserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DateParserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: DateParserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: DateParserService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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