@leanix/components 0.2.240 → 0.2.243

package/fesm2020/leanix-components.mjs

@@ -8,7 +8,7 @@ import * as i1 from '@angular/cdk/overlay';
 import { OverlayModule, CdkConnectedOverlay } from '@angular/cdk/overlay';
 import { __decorate } from 'tslib';
 import * as i6 from 'rxjs';
-import { BehaviorSubject, Subject, combineLatest, merge, concat, fromEvent, Observable, ReplaySubject, of, timer } from 'rxjs';
+import { BehaviorSubject, timer, Subject, combineLatest, merge, concat, fromEvent, Observable, ReplaySubject, of } from 'rxjs';
 import { skipWhile, map, switchMap, startWith, pairwise, filter, take, debounceTime, skip, withLatestFrom, distinctUntilChanged, takeUntil, first, delay, mapTo, tap } from 'rxjs/operators';
 import * as i1$1 from '@ngx-translate/core';
 import { TranslatePipe, TranslateModule } from '@ngx-translate/core';
@@ -513,7 +513,16 @@ function isResizeableElement(element) {
 class ResizeObserverService {
     observe(element, callback, options) {
         if (!this.resizeObserver) {
-            this.resizeObserver = new ResizeObserver(this.resizeObserverCallback.bind(this));
+            try {
+                this.resizeObserver = new ResizeObserver(this.resizeObserverCallback.bind(this));
+            }
+            catch {
+                // All the browsers we support implement the ResizeObserver API.
+                // For unsupported browsers, there's this "one time artifical resize event".
+                // They will not get the functionality tied to later resize events.
+                timer(500).subscribe(() => callback(this.getMockOneTimeResizeEventForUnsupportedBrowsers(element)));
+                return;
+            }
         }
         element.handleResize = callback;
         this.resizeObserver.observe(element, options);
@@ -531,6 +540,45 @@ class ResizeObserverService {
             }
         });
     }
+    /**
+     * All browsers we officially support implement the ResizeObserver API.
+     * Still as a curtesy do customers who for some reason have older browsers
+     * we call the callback once with the initial dimensions of the element
+     * and then do not react on resize events afterwards.
+     * This should still make them happier than a "browser not supported" warning.
+     */
+    getMockOneTimeResizeEventForUnsupportedBrowsers(element) {
+        const contentRect = {
+            bottom: element.clientHeight,
+            height: element.clientHeight,
+            left: 0,
+            right: element.clientWidth,
+            top: 0,
+            width: element.clientWidth,
+            x: 0,
+            y: 0
+        };
+        return {
+            borderBoxSize: [{ blockSize: element.clientHeight, inlineSize: element.clientWidth }],
+            contentBoxSize: [
+                {
+                    blockSize: element.clientHeight,
+                    inlineSize: element.clientWidth
+                }
+            ],
+            contentRect: {
+                ...contentRect,
+                toJSON: () => JSON.stringify(contentRect)
+            },
+            devicePixelContentBoxSize: [
+                {
+                    blockSize: element.clientWidth,
+                    inlineSize: element.clientWidth
+                }
+            ],
+            target: element
+        };
+    }
 }
 ResizeObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResizeObserverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
 ResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResizeObserverService, providedIn: 'root' });
@@ -1155,72 +1203,77 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImpor
 class LxLinkifyPipe {
     transform(text) {
         if (text && typeof text === 'string') {
-            let textWithRawLinks = text;
-            /**
-             * Keeping track of this index prevents infinite loops
-             * where a previously processed link starts with the same characters
-             * as a second link.
-             * e.g. https://angular.io/docs followed by https://angular.io
-             */
-            let nextIndexToStartReplacingFrom = 0;
-            const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);
-            rawLinkMatches.forEach((rawLinkMatch) => {
-                const [url] = rawLinkMatch;
-                const wrapUrlInAnchor = (sanitizedUrlMatch) => {
-                    const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);
-                    const anchorTagHtml = `<a href="${sanitizedUrlMatch}" target="_blank" rel="noopener noreferrer">${sanitizedUrlMatch}</a>`;
-                    const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch, anchorTagHtml);
-                    textWithRawLinks = firstPart + secondPart;
-                    nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;
-                };
-                if (url) {
-                    /*
-                     * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions
-                     * The following is RegExp that handles the same stuff as the JS code below:
-                     *
-                     * /(?:(?:(?<!\]\())(?:https|http):\/\/)(?:[^\s/$.?#][^\s]*(?<![\.)]))/gi;
-                     *
-                     * Demo on regex101: https://regex101.com/r/7Vl9bg/1
-                     *
-                     * Check lookbehind support here: https://caniuse.com/?search=lookbehind
-                     */
-                    const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;
-                    const textUsedToPerformMatching = rawLinkMatch.input;
-                    const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];
-                    if (lastCharacterInUrl === '.') {
-                        const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];
-                        if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\n') {
-                            const urlWithoutDotAtTheEnd = url.slice(0, -1);
-                            wrapUrlInAnchor(urlWithoutDotAtTheEnd);
-                        }
-                    }
-                    else if (rawLinkMatch.index > 3) {
-                        const twoCharactersInFrontOfTheLink = `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${textUsedToPerformMatching[rawLinkMatch.index - 1]}`;
-                        if (twoCharactersInFrontOfTheLink && twoCharactersInFrontOfTheLink !== '](') {
-                            // only wrap url in anchor when it is not a named markdown link
-                            wrapUrlInAnchor(url);
-                        }
-                    }
-                    else {
-                        wrapUrlInAnchor(url);
-                    }
-                }
-            });
-            let textWithRawAndNamedLinks = textWithRawLinks;
-            const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, textWithRawLinks);
-            namedLinkMatches.forEach((namedLinkMatch) => {
-                const [source, name, url] = namedLinkMatch;
-                const urlIsValid = url && !/javascript\:/i.test(url);
-                if (source && name && urlIsValid) {
-                    textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(source, `<a href="${url}" target="_blank" rel="noopener noreferrer">${name}</a>`);
-                }
-            });
+            const textWithRawLinks = this.wrapRawHttpLinksWithAnchorTags(text);
+            const textWithRawAndNamedLinks = this.turnMarkdownStyleLinksIntoAnchorTags(textWithRawLinks);
             return textWithRawAndNamedLinks;
         }
         else {
             return text;
         }
     }
+    turnMarkdownStyleLinksIntoAnchorTags(text) {
+        let textWithRawAndNamedLinks = text;
+        const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, text);
+        namedLinkMatches.forEach((namedLinkMatch) => {
+            const [source, name, url] = namedLinkMatch;
+            const urlIsValid = url && !/javascript\:/i.test(url);
+            if (source && name && urlIsValid) {
+                textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(source, `<a href="${url}" target="_blank" rel="noopener noreferrer">${name}</a>`);
+            }
+        });
+        return textWithRawAndNamedLinks;
+    }
+    wrapRawHttpLinksWithAnchorTags(text) {
+        let textWithRawLinks = text;
+        /**
+         * Keeping track of this index prevents infinite loops
+         * where a previously processed link starts with the same characters
+         * as a second link.
+         * e.g. https://angular.io/docs followed by https://angular.io
+         */
+        let nextIndexToStartReplacingFrom = 0;
+        const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);
+        rawLinkMatches.forEach((rawLinkMatch) => {
+            const [url] = rawLinkMatch;
+            const wrapUrlInAnchor = (sanitizedUrlMatch) => {
+                const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);
+                const anchorTagHtml = `<a href="${sanitizedUrlMatch}" target="_blank" rel="noopener noreferrer">${sanitizedUrlMatch}</a>`;
+                const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch, anchorTagHtml);
+                textWithRawLinks = firstPart + secondPart;
+                nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;
+            };
+            if (url) {
+                /*
+                 * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions
+                 * The following is RegExp that handles the same stuff as the JS code below:
+                 *
+                 * /(?:(?:(?<!\]\())(?:https|http):\/\/)(?:[^\s/$.?#][^\s]*(?<![\.)]))/gi;
+                 *
+                 * Demo on regex101: https://regex101.com/r/7Vl9bg/1
+                 *
+                 * Check lookbehind support here: https://caniuse.com/?search=lookbehind
+                 */
+                const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;
+                const textUsedToPerformMatching = rawLinkMatch.input;
+                const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];
+                const twoCharactersInFrontOfTheLink = rawLinkMatch.index > 3
+                    ? `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${textUsedToPerformMatching[rawLinkMatch.index - 1]}`
+                    : '';
+                const isMarkdownSyntaxLink = twoCharactersInFrontOfTheLink === '](';
+                if (!isMarkdownSyntaxLink && lastCharacterInUrl === '.') {
+                    const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];
+                    if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\n') {
+                        const urlWithoutDotAtTheEnd = url.slice(0, -1);
+                        wrapUrlInAnchor(urlWithoutDotAtTheEnd);
+                    }
+                }
+                else if (!isMarkdownSyntaxLink) {
+                    wrapUrlInAnchor(url);
+                }
+            }
+        });
+        return textWithRawLinks;
+    }
     getAllRegexMatches(regex, input) {
         let match;
         const matches = [];