stream-chat-angular 4.66.2 → 5.0.0-v5.10

package/assets/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.66.2";
+export declare const version = "5.0.0-v5.10";

package/{esm2015/assets/version.js → esm2020/assets/version.mjs}

@@ -1,2 +1,2 @@
-export const version = '4.66.2';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3N0cmVhbS1jaGF0LWFuZ3VsYXIvc3JjL2Fzc2V0cy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgdmVyc2lvbiA9ICc0LjY2LjInO1xuIl19
+export const version = '5.0.0-v5.10';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3N0cmVhbS1jaGF0LWFuZ3VsYXIvc3JjL2Fzc2V0cy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgdmVyc2lvbiA9ICc1LjAuMC12NS4xMCc7XG4iXX0=

package/esm2020/lib/attachment-configuration.service.mjs

@@ -0,0 +1,185 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * The `AttachmentConfigurationService` provides customization for certain attributes of attachments displayed inside the message component. If you're using your own CDN, you can integrate resizing features of it by providing your own handlers.
+ */
+export class AttachmentConfigurationService {
+    constructor() {
+        /**
+         * You can turn on/off thumbnail generation for video attachments
+         */
+        this.shouldGenerateVideoThumbnail = true;
+    }
+    /**
+     * Handles the configuration for image attachments, it's possible to provide your own function to override the default logic
+     * @param attachment The attachment to configure
+     * @param location Specifies where the image is being displayed
+     * @param element The default resizing logics reads the height/max-height and max-width propperties of this element and reduces file size based on the given values. File size reduction is done by Stream's CDN.
+     */
+    getImageAttachmentConfiguration(attachment, location, element) {
+        if (this.customImageAttachmentConfigurationHandler) {
+            return this.customImageAttachmentConfigurationHandler(attachment, location, element);
+        }
+        const defaultOriginalDimension = 1000000;
+        const urlString = (attachment.img_url ||
+            attachment.thumb_url ||
+            attachment.image_url ||
+            '');
+        let url;
+        try {
+            url = new URL(urlString);
+        }
+        catch (error) {
+            return {
+                url: urlString,
+                width: '',
+                height: '',
+                originalHeight: defaultOriginalDimension,
+                originalWidth: defaultOriginalDimension,
+            };
+        }
+        const originalHeight = Number(url.searchParams.get('oh')) > 1
+            ? Number(url.searchParams.get('oh'))
+            : defaultOriginalDimension;
+        const originalWidth = Number(url.searchParams.get('ow')) > 1
+            ? Number(url.searchParams.get('ow'))
+            : defaultOriginalDimension;
+        const displayWarning = location === 'gallery' || location === 'single';
+        const sizeRestriction = this.getSizingRestrictions(url, element, displayWarning);
+        if (sizeRestriction) {
+            // Apply 2x for retina displays
+            sizeRestriction.height *= 2;
+            sizeRestriction.width *= 2;
+            this.addResizingParamsToUrl(sizeRestriction, url);
+        }
+        return {
+            url: url.href,
+            width: '',
+            height: '',
+            originalHeight,
+            originalWidth,
+        };
+    }
+    /**
+     * Handles the configuration for video attachments, it's possible to provide your own function to override the default logic
+     * @param attachment The attachment to configure
+     * @param element The default resizing logics reads the height/max-height and max-width propperties of this element and reduces file size based on the given values. File size reduction is done by Stream's CDN.
+     */
+    getVideoAttachmentConfiguration(attachment, element) {
+        if (this.customVideoAttachmentConfigurationHandler) {
+            return this.customVideoAttachmentConfigurationHandler(attachment, element);
+        }
+        let thumbUrl = undefined;
+        let originalHeight = 1000000;
+        let originalWidth = 1000000;
+        if (attachment.thumb_url && this.shouldGenerateVideoThumbnail) {
+            let url;
+            try {
+                url = new URL(attachment.thumb_url);
+                originalHeight =
+                    Number(url.searchParams.get('oh')) > 1
+                        ? Number(url.searchParams.get('oh'))
+                        : originalHeight;
+                originalWidth =
+                    Number(url.searchParams.get('ow')) > 1
+                        ? Number(url.searchParams.get('ow'))
+                        : originalWidth;
+                const displayWarning = true;
+                const sizeRestriction = this.getSizingRestrictions(url, element, displayWarning);
+                if (sizeRestriction) {
+                    sizeRestriction.height *= 2;
+                    sizeRestriction.width *= 2;
+                    this.addResizingParamsToUrl(sizeRestriction, url);
+                }
+                thumbUrl = url.href;
+            }
+            catch {
+                thumbUrl = attachment.thumb_url;
+            }
+        }
+        return {
+            url: attachment.asset_url || '',
+            width: '',
+            height: '',
+            thumbUrl: thumbUrl,
+            originalHeight,
+            originalWidth,
+        };
+    }
+    /**
+     * Handles the configuration for giphy attachments, it's possible to provide your own function to override the default logic
+     * @param attachment The attachment to configure
+     */
+    getGiphyAttachmentConfiguration(attachment) {
+        if (this.customGiphyAttachmentConfigurationHandler) {
+            return this.customGiphyAttachmentConfigurationHandler(attachment);
+        }
+        const giphy = attachment.giphy?.fixed_height_downsampled;
+        return {
+            url: giphy?.url || attachment.image_url || attachment.thumb_url || '',
+            height: giphy?.height ? `${giphy?.height}px` : '300px',
+            width: giphy?.width ? `${giphy?.width}px` : '',
+        };
+    }
+    /**
+     * Handles the configuration for scraped image attachments, it's possible to provide your own function to override the default logic
+     * @param attachment The attachment to configure
+     */
+    getScrapedImageAttachmentConfiguration(attachment) {
+        if (this.customScrapedImageAttachmentConfigurationHandler) {
+            return this.customScrapedImageAttachmentConfigurationHandler(attachment);
+        }
+        return {
+            url: attachment.image_url || attachment.thumb_url || '',
+            width: '',
+            height: '', // Set from CSS
+        };
+    }
+    addResizingParamsToUrl(sizeRestriction, url) {
+        url.searchParams.set('h', sizeRestriction.height.toString());
+        url.searchParams.set('w', sizeRestriction.width.toString());
+    }
+    getSizingRestrictions(url, htmlElement, displayWarning = false) {
+        const urlParams = url.searchParams;
+        const originalHeight = Number(urlParams.get('oh')) || 1;
+        const originalWidth = Number(urlParams.get('ow')) || 1;
+        const cssSizeRestriction = this.getCSSSizeRestriction(htmlElement);
+        let sizeRestriction;
+        if ((cssSizeRestriction.maxHeight || cssSizeRestriction.height) &&
+            cssSizeRestriction.maxWidth) {
+            sizeRestriction = this.getSizeRestrictions(originalHeight, originalWidth, (cssSizeRestriction.maxHeight || cssSizeRestriction.height), cssSizeRestriction.maxWidth);
+        }
+        else {
+            sizeRestriction = undefined;
+            if (displayWarning) {
+                console.warn(`Invalid value set for height/max-height and/or max-width for HTML element, this can cause scrolling issues inside the message list, more info https://getstream.io/chat/docs/sdk/angular/components/AttachmentListComponent/#image-and-video-sizing, attachment URL: ${url.toString()}`);
+            }
+        }
+        return sizeRestriction;
+    }
+    getSizeRestrictions(originalHeight, originalWidth, maxHeight, maxWidth) {
+        return {
+            height: Math.round(Math.max(maxHeight, (maxWidth / originalWidth) * originalHeight)),
+            width: Math.round(Math.max(maxHeight, (maxWidth / originalHeight) * originalWidth)),
+        };
+    }
+    getCSSSizeRestriction(htmlElement) {
+        const computedStylesheet = getComputedStyle(htmlElement);
+        const height = this.getValueRepresentationOfCSSProperty(computedStylesheet.getPropertyValue('height'));
+        const maxHeight = this.getValueRepresentationOfCSSProperty(computedStylesheet.getPropertyValue('max-height'));
+        const maxWidth = this.getValueRepresentationOfCSSProperty(computedStylesheet.getPropertyValue('max-width'));
+        return { height, maxHeight, maxWidth };
+    }
+    getValueRepresentationOfCSSProperty(property) {
+        return Number(property.replace('px', '')) || undefined;
+    }
+}
+AttachmentConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AttachmentConfigurationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AttachmentConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AttachmentConfigurationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AttachmentConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attachment-configuration.service.js","sourceRoot":"","sources":["../../../../projects/stream-chat-angular/src/lib/attachment-configuration.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Attachment } from 'stream-chat';\nimport {\n  AttachmentConfigration,\n  DefaultStreamChatGenerics,\n  ImageAttachmentConfiguration,\n  VideoAttachmentConfiguration,\n} from './types';\n\n/**\n * The `AttachmentConfigurationService` provides customization for certain attributes of attachments displayed inside the message component. If you're using your own CDN, you can integrate resizing features of it by providing your own handlers.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class AttachmentConfigurationService<\n  T extends DefaultStreamChatGenerics = DefaultStreamChatGenerics\n> {\n  /**\n   * A custom handler can be provided to override the default image attachment (images uploaded from files) configuration. By default the SDK uses fixed image height (a size that's known before image is loaded), if you override that with dynamic image height (for example: height: 100%) the scrolling logic inside the message list can break.\n   */\n  customImageAttachmentConfigurationHandler?: (\n    a: Attachment<T>,\n    type: 'gallery' | 'single' | 'carousel',\n    containerElement: HTMLElement\n  ) => ImageAttachmentConfiguration;\n  /**\n   * A custom handler can be provided to override the default video attachment (videos uploaded from files) configuration. By default the SDK uses fixed height (a size that's known before video is loaded), if you override that with dynamic height (for example: height: 100%) the scrolling logic inside the message list can break.\n   */\n  customVideoAttachmentConfigurationHandler?: (\n    a: Attachment<T>,\n    containerElement: HTMLElement\n  ) => VideoAttachmentConfiguration;\n  /**\n   * A custom handler can be provided to override the default giphy attachment (GIFs sent with the /giphy command) configuration. By default the SDK uses fixed height (a size that's known before the GIF is loaded), if you override that with dynamic height (for example: height: 100%) the scrolling logic inside the message list can break.\n   */\n  customGiphyAttachmentConfigurationHandler?: (\n    a: Attachment<T>\n  ) => AttachmentConfigration;\n  /**\n   * A custom handler can be provided to override the default scraped image attachment (images found in links inside messages) configuration. By default the SDK uses fixed height (a size that's known before image is loaded), if you override that with dynamic height (for example: height: 100%) the scrolling logic inside the message list can break.\n   */\n  customScrapedImageAttachmentConfigurationHandler?: (\n    a: Attachment<T>\n  ) => AttachmentConfigration;\n  /**\n   * You can turn on/off thumbnail generation for video attachments\n   */\n  shouldGenerateVideoThumbnail = true;\n\n  /**\n   * Handles the configuration for image attachments, it's possible to provide your own function to override the default logic\n   * @param attachment The attachment to configure\n   * @param location Specifies where the image is being displayed\n   * @param element The default resizing logics reads the height/max-height and max-width propperties of this element and reduces file size based on the given values. File size reduction is done by Stream's CDN.\n   */\n  getImageAttachmentConfiguration(\n    attachment: Attachment<T>,\n    location: 'gallery' | 'single' | 'carousel',\n    element: HTMLElement\n  ): ImageAttachmentConfiguration {\n    if (this.customImageAttachmentConfigurationHandler) {\n      return this.customImageAttachmentConfigurationHandler(\n        attachment,\n        location,\n        element\n      );\n    }\n\n    const defaultOriginalDimension = 1000000;\n    const urlString = (attachment.img_url ||\n      attachment.thumb_url ||\n      attachment.image_url ||\n      '') as string;\n    let url: URL;\n    try {\n      url = new URL(urlString);\n    } catch (error) {\n      return {\n        url: urlString,\n        width: '', // Not set to respect responsive width\n        height: '', // Set from CSS\n        originalHeight: defaultOriginalDimension,\n        originalWidth: defaultOriginalDimension,\n      };\n    }\n    const originalHeight =\n      Number(url.searchParams.get('oh')) > 1\n        ? Number(url.searchParams.get('oh'))\n        : defaultOriginalDimension;\n    const originalWidth =\n      Number(url.searchParams.get('ow')) > 1\n        ? Number(url.searchParams.get('ow'))\n        : defaultOriginalDimension;\n    const displayWarning = location === 'gallery' || location === 'single';\n    const sizeRestriction = this.getSizingRestrictions(\n      url,\n      element,\n      displayWarning\n    );\n\n    if (sizeRestriction) {\n      // Apply 2x for retina displays\n      sizeRestriction.height *= 2;\n      sizeRestriction.width *= 2;\n      this.addResizingParamsToUrl(sizeRestriction, url);\n    }\n\n    return {\n      url: url.href,\n      width: '', // Not set to respect responsive width\n      height: '', // Set from CSS\n      originalHeight,\n      originalWidth,\n    };\n  }\n\n  /**\n   * Handles the configuration for video attachments, it's possible to provide your own function to override the default logic\n   * @param attachment The attachment to configure\n   * @param element The default resizing logics reads the height/max-height and max-width propperties of this element and reduces file size based on the given values. File size reduction is done by Stream's CDN.\n   */\n  getVideoAttachmentConfiguration(\n    attachment: Attachment<T>,\n    element: HTMLElement\n  ): VideoAttachmentConfiguration {\n    if (this.customVideoAttachmentConfigurationHandler) {\n      return this.customVideoAttachmentConfigurationHandler(\n        attachment,\n        element\n      );\n    }\n\n    let thumbUrl: string | undefined = undefined;\n    let originalHeight = 1000000;\n    let originalWidth = 1000000;\n    if (attachment.thumb_url && this.shouldGenerateVideoThumbnail) {\n      let url: URL;\n      try {\n        url = new URL(attachment.thumb_url);\n\n        originalHeight =\n          Number(url.searchParams.get('oh')) > 1\n            ? Number(url.searchParams.get('oh'))\n            : originalHeight;\n        originalWidth =\n          Number(url.searchParams.get('ow')) > 1\n            ? Number(url.searchParams.get('ow'))\n            : originalWidth;\n        const displayWarning = true;\n        const sizeRestriction = this.getSizingRestrictions(\n          url,\n          element,\n          displayWarning\n        );\n        if (sizeRestriction) {\n          sizeRestriction.height *= 2;\n          sizeRestriction.width *= 2;\n          this.addResizingParamsToUrl(sizeRestriction, url);\n        }\n        thumbUrl = url.href;\n      } catch {\n        thumbUrl = attachment.thumb_url;\n      }\n    }\n    return {\n      url: attachment.asset_url || '',\n      width: '', // Not set to respect responsive width\n      height: '', // Set from CSS\n      thumbUrl: thumbUrl,\n      originalHeight,\n      originalWidth,\n    };\n  }\n\n  /**\n   * Handles the configuration for giphy attachments, it's possible to provide your own function to override the default logic\n   * @param attachment The attachment to configure\n   */\n  getGiphyAttachmentConfiguration(\n    attachment: Attachment<T>\n  ): AttachmentConfigration {\n    if (this.customGiphyAttachmentConfigurationHandler) {\n      return this.customGiphyAttachmentConfigurationHandler(attachment);\n    }\n\n    const giphy = attachment.giphy?.fixed_height_downsampled;\n\n    return {\n      url: giphy?.url || attachment.image_url || attachment.thumb_url || '',\n      height: giphy?.height ? `${giphy?.height}px` : '300px',\n      width: giphy?.width ? `${giphy?.width}px` : '',\n    };\n  }\n\n  /**\n   * Handles the configuration for scraped image attachments, it's possible to provide your own function to override the default logic\n   * @param attachment The attachment to configure\n   */\n  getScrapedImageAttachmentConfiguration(\n    attachment: Attachment<T>\n  ): AttachmentConfigration {\n    if (this.customScrapedImageAttachmentConfigurationHandler) {\n      return this.customScrapedImageAttachmentConfigurationHandler(attachment);\n    }\n\n    return {\n      url: attachment.image_url || attachment.thumb_url || '',\n      width: '',\n      height: '', // Set from CSS\n    };\n  }\n\n  private addResizingParamsToUrl(\n    sizeRestriction: { width: number; height: number },\n    url: URL\n  ) {\n    url.searchParams.set('h', sizeRestriction.height.toString());\n    url.searchParams.set('w', sizeRestriction.width.toString());\n  }\n\n  private getSizingRestrictions(\n    url: URL,\n    htmlElement: HTMLElement,\n    displayWarning = false\n  ) {\n    const urlParams = url.searchParams;\n    const originalHeight = Number(urlParams.get('oh')) || 1;\n    const originalWidth = Number(urlParams.get('ow')) || 1;\n    const cssSizeRestriction = this.getCSSSizeRestriction(htmlElement);\n    let sizeRestriction: { width: number; height: number } | undefined;\n\n    if (\n      (cssSizeRestriction.maxHeight || cssSizeRestriction.height) &&\n      cssSizeRestriction.maxWidth\n    ) {\n      sizeRestriction = this.getSizeRestrictions(\n        originalHeight,\n        originalWidth,\n        (cssSizeRestriction.maxHeight || cssSizeRestriction.height)!,\n        cssSizeRestriction.maxWidth\n      );\n    } else {\n      sizeRestriction = undefined;\n      if (displayWarning) {\n        console.warn(\n          `Invalid value set for height/max-height and/or max-width for HTML element, this can cause scrolling issues inside the message list, more info https://getstream.io/chat/docs/sdk/angular/components/AttachmentListComponent/#image-and-video-sizing, attachment URL: ${url.toString()}`\n        );\n      }\n    }\n\n    return sizeRestriction;\n  }\n\n  private getSizeRestrictions(\n    originalHeight: number,\n    originalWidth: number,\n    maxHeight: number,\n    maxWidth: number\n  ) {\n    return {\n      height: Math.round(\n        Math.max(maxHeight, (maxWidth / originalWidth) * originalHeight)\n      ),\n      width: Math.round(\n        Math.max(maxHeight, (maxWidth / originalHeight) * originalWidth)\n      ),\n    };\n  }\n\n  private getCSSSizeRestriction(htmlElement: HTMLElement) {\n    const computedStylesheet = getComputedStyle(htmlElement);\n    const height = this.getValueRepresentationOfCSSProperty(\n      computedStylesheet.getPropertyValue('height')\n    );\n    const maxHeight = this.getValueRepresentationOfCSSProperty(\n      computedStylesheet.getPropertyValue('max-height')\n    );\n    const maxWidth = this.getValueRepresentationOfCSSProperty(\n      computedStylesheet.getPropertyValue('max-width')\n    );\n\n    return { height, maxHeight, maxWidth };\n  }\n\n  private getValueRepresentationOfCSSProperty(property: string) {\n    return Number(property.replace('px', '')) || undefined;\n  }\n}\n"]}