@leanix/components 0.2.240 → 0.2.243

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -13,72 +13,77 @@ import * as i0 from "@angular/core";
13
13
  export class LxLinkifyPipe {
14
14
  transform(text) {
15
15
  if (text && typeof text === 'string') {
16
- let textWithRawLinks = text;
17
- /**
18
- * Keeping track of this index prevents infinite loops
19
- * where a previously processed link starts with the same characters
20
- * as a second link.
21
- * e.g. https://angular.io/docs followed by https://angular.io
22
- */
23
- let nextIndexToStartReplacingFrom = 0;
24
- const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);
25
- rawLinkMatches.forEach((rawLinkMatch) => {
26
- const [url] = rawLinkMatch;
27
- const wrapUrlInAnchor = (sanitizedUrlMatch) => {
28
- const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);
29
- const anchorTagHtml = `<a href="${sanitizedUrlMatch}" target="_blank" rel="noopener noreferrer">${sanitizedUrlMatch}</a>`;
30
- const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch, anchorTagHtml);
31
- textWithRawLinks = firstPart + secondPart;
32
- nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;
33
- };
34
- if (url) {
35
- /*
36
- * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions
37
- * The following is RegExp that handles the same stuff as the JS code below:
38
- *
39
- * /(?:(?:(?<!\]\())(?:https|http):\/\/)(?:[^\s/$.?#][^\s]*(?<![\.)]))/gi;
40
- *
41
- * Demo on regex101: https://regex101.com/r/7Vl9bg/1
42
- *
43
- * Check lookbehind support here: https://caniuse.com/?search=lookbehind
44
- */
45
- const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;
46
- const textUsedToPerformMatching = rawLinkMatch.input;
47
- const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];
48
- if (lastCharacterInUrl === '.') {
49
- const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];
50
- if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\n') {
51
- const urlWithoutDotAtTheEnd = url.slice(0, -1);
52
- wrapUrlInAnchor(urlWithoutDotAtTheEnd);
53
- }
54
- }
55
- else if (rawLinkMatch.index > 3) {
56
- const twoCharactersInFrontOfTheLink = `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${textUsedToPerformMatching[rawLinkMatch.index - 1]}`;
57
- if (twoCharactersInFrontOfTheLink && twoCharactersInFrontOfTheLink !== '](') {
58
- // only wrap url in anchor when it is not a named markdown link
59
- wrapUrlInAnchor(url);
60
- }
61
- }
62
- else {
63
- wrapUrlInAnchor(url);
64
- }
65
- }
66
- });
67
- let textWithRawAndNamedLinks = textWithRawLinks;
68
- const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, textWithRawLinks);
69
- namedLinkMatches.forEach((namedLinkMatch) => {
70
- const [source, name, url] = namedLinkMatch;
71
- const urlIsValid = url && !/javascript\:/i.test(url);
72
- if (source && name && urlIsValid) {
73
- textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(source, `<a href="${url}" target="_blank" rel="noopener noreferrer">${name}</a>`);
74
- }
75
- });
16
+ const textWithRawLinks = this.wrapRawHttpLinksWithAnchorTags(text);
17
+ const textWithRawAndNamedLinks = this.turnMarkdownStyleLinksIntoAnchorTags(textWithRawLinks);
76
18
  return textWithRawAndNamedLinks;
77
19
  }
78
20
  else {
79
21
  return text;
80
22
  }
81
23
  }
24
+ turnMarkdownStyleLinksIntoAnchorTags(text) {
25
+ let textWithRawAndNamedLinks = text;
26
+ const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, text);
27
+ namedLinkMatches.forEach((namedLinkMatch) => {
28
+ const [source, name, url] = namedLinkMatch;
29
+ const urlIsValid = url && !/javascript\:/i.test(url);
30
+ if (source && name && urlIsValid) {
31
+ textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(source, `<a href="${url}" target="_blank" rel="noopener noreferrer">${name}</a>`);
32
+ }
33
+ });
34
+ return textWithRawAndNamedLinks;
35
+ }
36
+ wrapRawHttpLinksWithAnchorTags(text) {
37
+ let textWithRawLinks = text;
38
+ /**
39
+ * Keeping track of this index prevents infinite loops
40
+ * where a previously processed link starts with the same characters
41
+ * as a second link.
42
+ * e.g. https://angular.io/docs followed by https://angular.io
43
+ */
44
+ let nextIndexToStartReplacingFrom = 0;
45
+ const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);
46
+ rawLinkMatches.forEach((rawLinkMatch) => {
47
+ const [url] = rawLinkMatch;
48
+ const wrapUrlInAnchor = (sanitizedUrlMatch) => {
49
+ const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);
50
+ const anchorTagHtml = `<a href="${sanitizedUrlMatch}" target="_blank" rel="noopener noreferrer">${sanitizedUrlMatch}</a>`;
51
+ const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch, anchorTagHtml);
52
+ textWithRawLinks = firstPart + secondPart;
53
+ nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;
54
+ };
55
+ if (url) {
56
+ /*
57
+ * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions
58
+ * The following is RegExp that handles the same stuff as the JS code below:
59
+ *
60
+ * /(?:(?:(?<!\]\())(?:https|http):\/\/)(?:[^\s/$.?#][^\s]*(?<![\.)]))/gi;
61
+ *
62
+ * Demo on regex101: https://regex101.com/r/7Vl9bg/1
63
+ *
64
+ * Check lookbehind support here: https://caniuse.com/?search=lookbehind
65
+ */
66
+ const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;
67
+ const textUsedToPerformMatching = rawLinkMatch.input;
68
+ const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];
69
+ const twoCharactersInFrontOfTheLink = rawLinkMatch.index > 3
70
+ ? `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${textUsedToPerformMatching[rawLinkMatch.index - 1]}`
71
+ : '';
72
+ const isMarkdownSyntaxLink = twoCharactersInFrontOfTheLink === '](';
73
+ if (!isMarkdownSyntaxLink && lastCharacterInUrl === '.') {
74
+ const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];
75
+ if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\n') {
76
+ const urlWithoutDotAtTheEnd = url.slice(0, -1);
77
+ wrapUrlInAnchor(urlWithoutDotAtTheEnd);
78
+ }
79
+ }
80
+ else if (!isMarkdownSyntaxLink) {
81
+ wrapUrlInAnchor(url);
82
+ }
83
+ }
84
+ });
85
+ return textWithRawLinks;
86
+ }
82
87
  getAllRegexMatches(regex, input) {
83
88
  let match;
84
89
  const matches = [];
@@ -122,4 +127,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImpor
122
127
  type: Pipe,
123
128
  args: [{ name: 'lxLinkify' }]
124
129
  }] });
125
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linkify.pipe.js","sourceRoot":"","sources":["../../../../../../../../libs/components/src/lib/core-ui/pipes/linkify/linkify.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\n\n/**\n * This pipe transforms...\n * - \"raw\" http(s) links\n * - markdown link syntax\n * ... into clickable anchor elements.\n *\n * You have an user interface where you don't want clickable links but also\n * don't want users to see the \"ugly\" markdown link syntax?\n * -> Use the 'lxUnlikify' pipe to replace markdown link syntax with just the link name\n */\n@Pipe({ name: 'lxLinkify' })\nexport class LxLinkifyPipe implements PipeTransform {\n  /**\n   * This is not the \"one URL regex to rule them all\", but a more realistic one which should work\n   * for any URLs that our customers include in text fields on a Fact Sheet.\n   *\n   * Regex rules explained in plain text:\n   *\n   * (?:(?:https?):\\/\\/)       ->    Links must start with \"https://\" or \"http://\"\n   *\n   * (?:[^\\s/$.?#][^\\s]*(?<![\\.)])) LET'S SPLIT THIS ONE UP\n   *\n   * [^\\s/$.?#][^\\s]*   ->    Match any legal URL character until the next whitespace\n   * (?<![\\.)]          ->    A negative lookahead to prevent matching a dot or parenthesis following a URL\n   *\n   * Link to regex101: https://regex101.com/r/d3KtfH/1 (NOTE: please update this link when changing the regex)\n   */\n  public static readonly HTTP_LINK_REGEX = /(?:(?:https?):\\/\\/)(?:[^\\s/$.?#][^\\s]*)/gi;\n\n  /**\n   * This will match the markdown link syntax: [link name](url)\n   * Regex rules explained in plain text:\n   *\n   * (?:\\[([^\\]]*)\\])            ->     Match any characters inside square brackets\n   * \\(([^\\s\\/$.?#][^\\s]*)\\)     ->     Notice that this is the same regex as the HTTP_LINK_REGEX above,\n   *                                    but without the requirement for the http protocol.\n   *                                    This allows for links without including the protocol or also \"mailto:hello@world.de\" links\n   *\n   * Link to regex101: https://regex101.com/r/5UMUH8/1\n   */\n  public static readonly NAMED_LINK_REGEX = /(?:\\[([^\\]]*)\\])\\(([^\\s\\/$.?#][^\\s]*)\\)/gi;\n\n  transform(text?: string | null): string | undefined | null {\n    if (text && typeof text === 'string') {\n      let textWithRawLinks = text;\n      /**\n       * Keeping track of this index prevents infinite loops\n       * where a previously processed link starts with the same characters\n       * as a second link.\n       * e.g. https://angular.io/docs followed by https://angular.io\n       */\n      let nextIndexToStartReplacingFrom = 0;\n      const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);\n      rawLinkMatches.forEach((rawLinkMatch) => {\n        const [url] = rawLinkMatch;\n        const wrapUrlInAnchor = (sanitizedUrlMatch: string) => {\n          const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);\n          const anchorTagHtml = `<a href=\"${sanitizedUrlMatch}\" target=\"_blank\" rel=\"noopener noreferrer\">${sanitizedUrlMatch}</a>`;\n          const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch!, anchorTagHtml);\n          textWithRawLinks = firstPart + secondPart;\n          nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;\n        };\n        if (url) {\n          /*\n           * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions\n           * The following is RegExp that handles the same stuff as the JS code below:\n           *\n           * /(?:(?:(?<!\\]\\())(?:https|http):\\/\\/)(?:[^\\s/$.?#][^\\s]*(?<![\\.)]))/gi;\n           *\n           * Demo on regex101: https://regex101.com/r/7Vl9bg/1\n           *\n           * Check lookbehind support here: https://caniuse.com/?search=lookbehind\n           */\n          const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;\n          const textUsedToPerformMatching = rawLinkMatch.input;\n          const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];\n          if (lastCharacterInUrl === '.') {\n            const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];\n            if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\\n') {\n              const urlWithoutDotAtTheEnd = url.slice(0, -1);\n              wrapUrlInAnchor(urlWithoutDotAtTheEnd);\n            }\n          } else if (rawLinkMatch.index > 3) {\n            const twoCharactersInFrontOfTheLink = `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${\n              textUsedToPerformMatching[rawLinkMatch.index - 1]\n            }`;\n            if (twoCharactersInFrontOfTheLink && twoCharactersInFrontOfTheLink !== '](') {\n              // only wrap url in anchor when it is not a named markdown link\n              wrapUrlInAnchor(url);\n            }\n          } else {\n            wrapUrlInAnchor(url);\n          }\n        }\n      });\n\n      let textWithRawAndNamedLinks = textWithRawLinks;\n      const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, textWithRawLinks);\n      namedLinkMatches.forEach((namedLinkMatch) => {\n        const [source, name, url] = namedLinkMatch;\n        const urlIsValid = url && !/javascript\\:/i.test(url);\n        if (source && name && urlIsValid) {\n          textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(\n            source,\n            `<a href=\"${url}\" target=\"_blank\" rel=\"noopener noreferrer\">${name}</a>`\n          );\n        }\n      });\n\n      return textWithRawAndNamedLinks;\n    } else {\n      return text;\n    }\n  }\n\n  private getAllRegexMatches(regex: RegExp, input: string) {\n    let match: RegExpExecArray | null;\n    const matches = [];\n    while ((match = regex.exec(input)) !== null) {\n      matches.push(match);\n    }\n    return matches;\n  }\n}\n"]}
130
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linkify.pipe.js","sourceRoot":"","sources":["../../../../../../../../libs/components/src/lib/core-ui/pipes/linkify/linkify.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\n\n/**\n * This pipe transforms...\n * - \"raw\" http(s) links\n * - markdown link syntax\n * ... into clickable anchor elements.\n *\n * You have an user interface where you don't want clickable links but also\n * don't want users to see the \"ugly\" markdown link syntax?\n * -> Use the 'lxUnlikify' pipe to replace markdown link syntax with just the link name\n */\n@Pipe({ name: 'lxLinkify' })\nexport class LxLinkifyPipe implements PipeTransform {\n  /**\n   * This is not the \"one URL regex to rule them all\", but a more realistic one which should work\n   * for any URLs that our customers include in text fields on a Fact Sheet.\n   *\n   * Regex rules explained in plain text:\n   *\n   * (?:(?:https?):\\/\\/)       ->    Links must start with \"https://\" or \"http://\"\n   *\n   * (?:[^\\s/$.?#][^\\s]*(?<![\\.)])) LET'S SPLIT THIS ONE UP\n   *\n   * [^\\s/$.?#][^\\s]*   ->    Match any legal URL character until the next whitespace\n   * (?<![\\.)]          ->    A negative lookahead to prevent matching a dot or parenthesis following a URL\n   *\n   * Link to regex101: https://regex101.com/r/d3KtfH/1 (NOTE: please update this link when changing the regex)\n   */\n  public static readonly HTTP_LINK_REGEX = /(?:(?:https?):\\/\\/)(?:[^\\s/$.?#][^\\s]*)/gi;\n\n  /**\n   * This will match the markdown link syntax: [link name](url)\n   * Regex rules explained in plain text:\n   *\n   * (?:\\[([^\\]]*)\\])            ->     Match any characters inside square brackets\n   * \\(([^\\s\\/$.?#][^\\s]*)\\)     ->     Notice that this is the same regex as the HTTP_LINK_REGEX above,\n   *                                    but without the requirement for the http protocol.\n   *                                    This allows for links without including the protocol or also \"mailto:hello@world.de\" links\n   *\n   * Link to regex101: https://regex101.com/r/5UMUH8/1\n   */\n  public static readonly NAMED_LINK_REGEX = /(?:\\[([^\\]]*)\\])\\(([^\\s\\/$.?#][^\\s]*)\\)/gi;\n\n  transform(text?: string | null): string | undefined | null {\n    if (text && typeof text === 'string') {\n      const textWithRawLinks = this.wrapRawHttpLinksWithAnchorTags(text);\n      const textWithRawAndNamedLinks = this.turnMarkdownStyleLinksIntoAnchorTags(textWithRawLinks);\n      return textWithRawAndNamedLinks;\n    } else {\n      return text;\n    }\n  }\n\n  private turnMarkdownStyleLinksIntoAnchorTags(text: string) {\n    let textWithRawAndNamedLinks = text;\n    const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, text);\n    namedLinkMatches.forEach((namedLinkMatch) => {\n      const [source, name, url] = namedLinkMatch;\n      const urlIsValid = url && !/javascript\\:/i.test(url);\n      if (source && name && urlIsValid) {\n        textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(\n          source,\n          `<a href=\"${url}\" target=\"_blank\" rel=\"noopener noreferrer\">${name}</a>`\n        );\n      }\n    });\n    return textWithRawAndNamedLinks;\n  }\n\n  private wrapRawHttpLinksWithAnchorTags(text: string) {\n    let textWithRawLinks = text;\n    /**\n     * Keeping track of this index prevents infinite loops\n     * where a previously processed link starts with the same characters\n     * as a second link.\n     * e.g. https://angular.io/docs followed by https://angular.io\n     */\n    let nextIndexToStartReplacingFrom = 0;\n    const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);\n    rawLinkMatches.forEach((rawLinkMatch) => {\n      const [url] = rawLinkMatch;\n      const wrapUrlInAnchor = (sanitizedUrlMatch: string) => {\n        const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);\n        const anchorTagHtml = `<a href=\"${sanitizedUrlMatch}\" target=\"_blank\" rel=\"noopener noreferrer\">${sanitizedUrlMatch}</a>`;\n        const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch!, anchorTagHtml);\n        textWithRawLinks = firstPart + secondPart;\n        nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;\n      };\n      if (url) {\n        /*\n         * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions\n         * The following is RegExp that handles the same stuff as the JS code below:\n         *\n         * /(?:(?:(?<!\\]\\())(?:https|http):\\/\\/)(?:[^\\s/$.?#][^\\s]*(?<![\\.)]))/gi;\n         *\n         * Demo on regex101: https://regex101.com/r/7Vl9bg/1\n         *\n         * Check lookbehind support here: https://caniuse.com/?search=lookbehind\n         */\n        const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;\n        const textUsedToPerformMatching = rawLinkMatch.input;\n        const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];\n        const twoCharactersInFrontOfTheLink =\n          rawLinkMatch.index > 3\n            ? `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${textUsedToPerformMatching[rawLinkMatch.index - 1]}`\n            : '';\n        const isMarkdownSyntaxLink = twoCharactersInFrontOfTheLink === '](';\n\n        if (!isMarkdownSyntaxLink && lastCharacterInUrl === '.') {\n          const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];\n          if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\\n') {\n            const urlWithoutDotAtTheEnd = url.slice(0, -1);\n            wrapUrlInAnchor(urlWithoutDotAtTheEnd);\n          }\n        } else if (!isMarkdownSyntaxLink) {\n          wrapUrlInAnchor(url);\n        }\n      }\n    });\n    return textWithRawLinks;\n  }\n\n  private getAllRegexMatches(regex: RegExp, input: string) {\n    let match: RegExpExecArray | null;\n    const matches = [];\n    while ((match = regex.exec(input)) !== null) {\n      matches.push(match);\n    }\n    return matches;\n  }\n}\n"]}
@@ -1,4 +1,5 @@
1
1
  import { Injectable } from '@angular/core';
2
+ import { timer } from 'rxjs';
2
3
  import * as i0 from "@angular/core";
3
4
  function isResizeableElement(element) {
4
5
  return element && !!element.handleResize;
@@ -19,7 +20,16 @@ function isResizeableElement(element) {
19
20
  export class ResizeObserverService {
20
21
  observe(element, callback, options) {
21
22
  if (!this.resizeObserver) {
22
- this.resizeObserver = new ResizeObserver(this.resizeObserverCallback.bind(this));
23
+ try {
24
+ this.resizeObserver = new ResizeObserver(this.resizeObserverCallback.bind(this));
25
+ }
26
+ catch {
27
+ // All the browsers we support implement the ResizeObserver API.
28
+ // For unsupported browsers, there's this "one time artifical resize event".
29
+ // They will not get the functionality tied to later resize events.
30
+ timer(500).subscribe(() => callback(this.getMockOneTimeResizeEventForUnsupportedBrowsers(element)));
31
+ return;
32
+ }
23
33
  }
24
34
  element.handleResize = callback;
25
35
  this.resizeObserver.observe(element, options);
@@ -37,6 +47,45 @@ export class ResizeObserverService {
37
47
  }
38
48
  });
39
49
  }
50
+ /**
51
+ * All browsers we officially support implement the ResizeObserver API.
52
+ * Still as a curtesy do customers who for some reason have older browsers
53
+ * we call the callback once with the initial dimensions of the element
54
+ * and then do not react on resize events afterwards.
55
+ * This should still make them happier than a "browser not supported" warning.
56
+ */
57
+ getMockOneTimeResizeEventForUnsupportedBrowsers(element) {
58
+ const contentRect = {
59
+ bottom: element.clientHeight,
60
+ height: element.clientHeight,
61
+ left: 0,
62
+ right: element.clientWidth,
63
+ top: 0,
64
+ width: element.clientWidth,
65
+ x: 0,
66
+ y: 0
67
+ };
68
+ return {
69
+ borderBoxSize: [{ blockSize: element.clientHeight, inlineSize: element.clientWidth }],
70
+ contentBoxSize: [
71
+ {
72
+ blockSize: element.clientHeight,
73
+ inlineSize: element.clientWidth
74
+ }
75
+ ],
76
+ contentRect: {
77
+ ...contentRect,
78
+ toJSON: () => JSON.stringify(contentRect)
79
+ },
80
+ devicePixelContentBoxSize: [
81
+ {
82
+ blockSize: element.clientWidth,
83
+ inlineSize: element.clientWidth
84
+ }
85
+ ],
86
+ target: element
87
+ };
88
+ }
40
89
  }
41
90
  ResizeObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResizeObserverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
42
91
  ResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResizeObserverService, providedIn: 'root' });
@@ -44,4 +93,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImpor
44
93
  type: Injectable,
45
94
  args: [{ providedIn: 'root' }]
46
95
  }] });
47
- //# sourceMappingURL=data:application/json;base64,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
96
+ //# sourceMappingURL=data:application/json;base64,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
@@ -8,7 +8,7 @@ import * as i1 from '@angular/cdk/overlay';
8
8
  import { OverlayModule, CdkConnectedOverlay } from '@angular/cdk/overlay';
9
9
  import { __decorate, __awaiter } from 'tslib';
10
10
  import * as i6 from 'rxjs';
11
- import { BehaviorSubject, Subject, combineLatest, merge, concat, fromEvent, Observable, ReplaySubject, of, timer } from 'rxjs';
11
+ import { BehaviorSubject, timer, Subject, combineLatest, merge, concat, fromEvent, Observable, ReplaySubject, of } from 'rxjs';
12
12
  import { skipWhile, map, switchMap, startWith, pairwise, filter, take, debounceTime, skip, withLatestFrom, distinctUntilChanged, takeUntil, first, delay, mapTo, tap } from 'rxjs/operators';
13
13
  import * as i1$1 from '@ngx-translate/core';
14
14
  import { TranslatePipe, TranslateModule } from '@ngx-translate/core';
@@ -518,7 +518,16 @@ function isResizeableElement(element) {
518
518
  class ResizeObserverService {
519
519
  observe(element, callback, options) {
520
520
  if (!this.resizeObserver) {
521
- this.resizeObserver = new ResizeObserver(this.resizeObserverCallback.bind(this));
521
+ try {
522
+ this.resizeObserver = new ResizeObserver(this.resizeObserverCallback.bind(this));
523
+ }
524
+ catch (_a) {
525
+ // All the browsers we support implement the ResizeObserver API.
526
+ // For unsupported browsers, there's this "one time artifical resize event".
527
+ // They will not get the functionality tied to later resize events.
528
+ timer(500).subscribe(() => callback(this.getMockOneTimeResizeEventForUnsupportedBrowsers(element)));
529
+ return;
530
+ }
522
531
  }
523
532
  element.handleResize = callback;
524
533
  this.resizeObserver.observe(element, options);
@@ -536,6 +545,42 @@ class ResizeObserverService {
536
545
  }
537
546
  });
538
547
  }
548
+ /**
549
+ * All browsers we officially support implement the ResizeObserver API.
550
+ * Still as a curtesy do customers who for some reason have older browsers
551
+ * we call the callback once with the initial dimensions of the element
552
+ * and then do not react on resize events afterwards.
553
+ * This should still make them happier than a "browser not supported" warning.
554
+ */
555
+ getMockOneTimeResizeEventForUnsupportedBrowsers(element) {
556
+ const contentRect = {
557
+ bottom: element.clientHeight,
558
+ height: element.clientHeight,
559
+ left: 0,
560
+ right: element.clientWidth,
561
+ top: 0,
562
+ width: element.clientWidth,
563
+ x: 0,
564
+ y: 0
565
+ };
566
+ return {
567
+ borderBoxSize: [{ blockSize: element.clientHeight, inlineSize: element.clientWidth }],
568
+ contentBoxSize: [
569
+ {
570
+ blockSize: element.clientHeight,
571
+ inlineSize: element.clientWidth
572
+ }
573
+ ],
574
+ contentRect: Object.assign(Object.assign({}, contentRect), { toJSON: () => JSON.stringify(contentRect) }),
575
+ devicePixelContentBoxSize: [
576
+ {
577
+ blockSize: element.clientWidth,
578
+ inlineSize: element.clientWidth
579
+ }
580
+ ],
581
+ target: element
582
+ };
583
+ }
539
584
  }
540
585
  ResizeObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResizeObserverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
541
586
  ResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResizeObserverService, providedIn: 'root' });
@@ -1167,72 +1212,77 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImpor
1167
1212
  class LxLinkifyPipe {
1168
1213
  transform(text) {
1169
1214
  if (text && typeof text === 'string') {
1170
- let textWithRawLinks = text;
1171
- /**
1172
- * Keeping track of this index prevents infinite loops
1173
- * where a previously processed link starts with the same characters
1174
- * as a second link.
1175
- * e.g. https://angular.io/docs followed by https://angular.io
1176
- */
1177
- let nextIndexToStartReplacingFrom = 0;
1178
- const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);
1179
- rawLinkMatches.forEach((rawLinkMatch) => {
1180
- const [url] = rawLinkMatch;
1181
- const wrapUrlInAnchor = (sanitizedUrlMatch) => {
1182
- const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);
1183
- const anchorTagHtml = `<a href="${sanitizedUrlMatch}" target="_blank" rel="noopener noreferrer">${sanitizedUrlMatch}</a>`;
1184
- const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch, anchorTagHtml);
1185
- textWithRawLinks = firstPart + secondPart;
1186
- nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;
1187
- };
1188
- if (url) {
1189
- /*
1190
- * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions
1191
- * The following is RegExp that handles the same stuff as the JS code below:
1192
- *
1193
- * /(?:(?:(?<!\]\())(?:https|http):\/\/)(?:[^\s/$.?#][^\s]*(?<![\.)]))/gi;
1194
- *
1195
- * Demo on regex101: https://regex101.com/r/7Vl9bg/1
1196
- *
1197
- * Check lookbehind support here: https://caniuse.com/?search=lookbehind
1198
- */
1199
- const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;
1200
- const textUsedToPerformMatching = rawLinkMatch.input;
1201
- const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];
1202
- if (lastCharacterInUrl === '.') {
1203
- const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];
1204
- if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\n') {
1205
- const urlWithoutDotAtTheEnd = url.slice(0, -1);
1206
- wrapUrlInAnchor(urlWithoutDotAtTheEnd);
1207
- }
1208
- }
1209
- else if (rawLinkMatch.index > 3) {
1210
- const twoCharactersInFrontOfTheLink = `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${textUsedToPerformMatching[rawLinkMatch.index - 1]}`;
1211
- if (twoCharactersInFrontOfTheLink && twoCharactersInFrontOfTheLink !== '](') {
1212
- // only wrap url in anchor when it is not a named markdown link
1213
- wrapUrlInAnchor(url);
1214
- }
1215
- }
1216
- else {
1217
- wrapUrlInAnchor(url);
1218
- }
1219
- }
1220
- });
1221
- let textWithRawAndNamedLinks = textWithRawLinks;
1222
- const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, textWithRawLinks);
1223
- namedLinkMatches.forEach((namedLinkMatch) => {
1224
- const [source, name, url] = namedLinkMatch;
1225
- const urlIsValid = url && !/javascript\:/i.test(url);
1226
- if (source && name && urlIsValid) {
1227
- textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(source, `<a href="${url}" target="_blank" rel="noopener noreferrer">${name}</a>`);
1228
- }
1229
- });
1215
+ const textWithRawLinks = this.wrapRawHttpLinksWithAnchorTags(text);
1216
+ const textWithRawAndNamedLinks = this.turnMarkdownStyleLinksIntoAnchorTags(textWithRawLinks);
1230
1217
  return textWithRawAndNamedLinks;
1231
1218
  }
1232
1219
  else {
1233
1220
  return text;
1234
1221
  }
1235
1222
  }
1223
+ turnMarkdownStyleLinksIntoAnchorTags(text) {
1224
+ let textWithRawAndNamedLinks = text;
1225
+ const namedLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.NAMED_LINK_REGEX, text);
1226
+ namedLinkMatches.forEach((namedLinkMatch) => {
1227
+ const [source, name, url] = namedLinkMatch;
1228
+ const urlIsValid = url && !/javascript\:/i.test(url);
1229
+ if (source && name && urlIsValid) {
1230
+ textWithRawAndNamedLinks = textWithRawAndNamedLinks.replace(source, `<a href="${url}" target="_blank" rel="noopener noreferrer">${name}</a>`);
1231
+ }
1232
+ });
1233
+ return textWithRawAndNamedLinks;
1234
+ }
1235
+ wrapRawHttpLinksWithAnchorTags(text) {
1236
+ let textWithRawLinks = text;
1237
+ /**
1238
+ * Keeping track of this index prevents infinite loops
1239
+ * where a previously processed link starts with the same characters
1240
+ * as a second link.
1241
+ * e.g. https://angular.io/docs followed by https://angular.io
1242
+ */
1243
+ let nextIndexToStartReplacingFrom = 0;
1244
+ const rawLinkMatches = this.getAllRegexMatches(LxLinkifyPipe.HTTP_LINK_REGEX, text);
1245
+ rawLinkMatches.forEach((rawLinkMatch) => {
1246
+ const [url] = rawLinkMatch;
1247
+ const wrapUrlInAnchor = (sanitizedUrlMatch) => {
1248
+ const firstPart = textWithRawLinks.substring(0, nextIndexToStartReplacingFrom);
1249
+ const anchorTagHtml = `<a href="${sanitizedUrlMatch}" target="_blank" rel="noopener noreferrer">${sanitizedUrlMatch}</a>`;
1250
+ const secondPart = textWithRawLinks.substring(nextIndexToStartReplacingFrom).replace(sanitizedUrlMatch, anchorTagHtml);
1251
+ textWithRawLinks = firstPart + secondPart;
1252
+ nextIndexToStartReplacingFrom = rawLinkMatch.index + anchorTagHtml.length;
1253
+ };
1254
+ if (url) {
1255
+ /*
1256
+ * TODO: get rid of all this code once Safari supports negative lookbehinds in regular expressions
1257
+ * The following is RegExp that handles the same stuff as the JS code below:
1258
+ *
1259
+ * /(?:(?:(?<!\]\())(?:https|http):\/\/)(?:[^\s/$.?#][^\s]*(?<![\.)]))/gi;
1260
+ *
1261
+ * Demo on regex101: https://regex101.com/r/7Vl9bg/1
1262
+ *
1263
+ * Check lookbehind support here: https://caniuse.com/?search=lookbehind
1264
+ */
1265
+ const lastUrlCharacterIndex = rawLinkMatch.index + url.length - 1;
1266
+ const textUsedToPerformMatching = rawLinkMatch.input;
1267
+ const lastCharacterInUrl = textUsedToPerformMatching[lastUrlCharacterIndex];
1268
+ const twoCharactersInFrontOfTheLink = rawLinkMatch.index > 3
1269
+ ? `${textUsedToPerformMatching[rawLinkMatch.index - 2]}${textUsedToPerformMatching[rawLinkMatch.index - 1]}`
1270
+ : '';
1271
+ const isMarkdownSyntaxLink = twoCharactersInFrontOfTheLink === '](';
1272
+ if (!isMarkdownSyntaxLink && lastCharacterInUrl === '.') {
1273
+ const characterAfterUrl = textUsedToPerformMatching[lastUrlCharacterIndex + 1];
1274
+ if (!characterAfterUrl || characterAfterUrl === ' ' || characterAfterUrl === '\n') {
1275
+ const urlWithoutDotAtTheEnd = url.slice(0, -1);
1276
+ wrapUrlInAnchor(urlWithoutDotAtTheEnd);
1277
+ }
1278
+ }
1279
+ else if (!isMarkdownSyntaxLink) {
1280
+ wrapUrlInAnchor(url);
1281
+ }
1282
+ }
1283
+ });
1284
+ return textWithRawLinks;
1285
+ }
1236
1286
  getAllRegexMatches(regex, input) {
1237
1287
  let match;
1238
1288
  const matches = [];