@sumaris-net/ngx-components 18.5.14 → 18.6.0

package/esm2022/src/app/shared/markdown/markdown.service.mjs

@@ -0,0 +1,202 @@
+import { inject, Injectable } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ModalController, NavController } from '@ionic/angular';
+import { LocationStrategy } from '@angular/common';
+import { MarkedRenderer } from 'ngx-markdown';
+import { UrlUtils } from '../file/url.utils';
+import { Subject, Subscription } from 'rxjs';
+import { isNotNilOrBlank } from '../functions';
+import { MarkdownUtils } from './markdown.utils';
+import { PlatformService } from '../../core/services/platform.service';
+import * as i0 from "@angular/core";
+export class MarkdownService {
+    route = inject(ActivatedRoute);
+    router = inject(Router);
+    platform = inject(PlatformService);
+    locationStrategy = inject(LocationStrategy);
+    navController = inject(NavController);
+    modalCtrl = inject(ModalController);
+    baseUrl;
+    _defaultRenderer = new MarkedRenderer();
+    _markedRenderer;
+    get renderer() {
+        return this._markedRenderer;
+    }
+    set renderer(value) {
+        this.setRenderer(value);
+    }
+    onClickMarkdownUrl = new Subject();
+    constructor() {
+        this.setRenderer(new MarkedRenderer());
+    }
+    setBaseUrl(baseUrl) {
+        console.debug('[markdown-service] Base URL: ' + baseUrl);
+        this.baseUrl = baseUrl;
+    }
+    resetBaseUrl() {
+        this.setBaseUrl(null);
+    }
+    getUrlTree(url) {
+        url = UrlUtils.normalizeUrl(url);
+        const urlPath = UrlUtils.stripFragmentAndQuery(url) || UrlUtils.stripFragmentAndQuery(this.router.url);
+        const parsedUrl = this.router.parseUrl(url);
+        const fragment = parsedUrl.fragment;
+        const queryParams = parsedUrl.queryParams;
+        return this.router.createUrlTree([urlPath], { relativeTo: this.route, fragment, queryParams });
+    }
+    navigate(url, replaceUrl = false) {
+        const urlTree = this.getUrlTree(url);
+        this.router.navigated = false;
+        this.navController.navigateForward(urlTree, { replaceUrl });
+    }
+    listenClickEvents(nativeElement) {
+        console.debug('[markdown-service] Start listening click events...');
+        const subscription = new Subscription();
+        const listener = (event) => this.click(event, nativeElement);
+        const links = nativeElement.querySelectorAll('a');
+        links.forEach((link) => {
+            // DEBUG
+            //console.debug('[markdown-service] Adding click listener to', link);
+            link.addEventListener('click', listener);
+            subscription.add(() => link.removeEventListener('click', listener));
+        });
+        // DEBUG
+        subscription.add(() => console.debug('[markdown-service] Stop listening click events'));
+        return subscription;
+    }
+    /**
+     * Transform a relative URL to its absolute representation according to current router state.
+     * @param url Relative URL path.
+     * @return Absolute URL based on the current route.
+     */
+    normalizeUrl(url) {
+        if (UrlUtils.isExternalUrl(url)) {
+            return url;
+        }
+        if (this.baseUrl && UrlUtils.isRelativeUrl(url)) {
+            return MarkdownUtils.resolveRelativeUrl(this.baseUrl, url);
+        }
+        const urlTree = this.getUrlTree(url);
+        const serializedUrl = this.router.serializeUrl(urlTree);
+        return this.locationStrategy.prepareExternalUrl(serializedUrl);
+    }
+    scrollToAnchor(containerElement, anchorId) {
+        if (!containerElement || !anchorId) {
+            console.warn("Missing 'containerElement' or 'fragment' argument.");
+            return;
+        }
+        console.debug('[markdown-anchor] Scrolling to anchor #' + anchorId);
+        // Find the target element with the specified fragment ID
+        let targetElement = containerElement.querySelector(`#${anchorId}`);
+        // If not found, retry fix a fixed anchor id. This can occur when ToC has been generated for the maven-markdown-plugin
+        if (!targetElement) {
+            targetElement = containerElement.querySelector(`#${MarkdownUtils.fixAnchor(anchorId)}`);
+        }
+        if (targetElement) {
+            // Scroll smoothly to the target element
+            targetElement.scrollIntoView({
+                behavior: 'smooth', // Smooth scrolling behavior
+                block: 'start', // Align the target element to the top of the container
+            });
+        }
+        else {
+            console.warn(`No element found with the ID "${anchorId}" inside the container.`);
+        }
+    }
+    /* -- protected function -- */
+    setRenderer(renderer) {
+        console.debug('[markdown-service] Set renderer', renderer);
+        renderer.link = (href, title, text) => this.link(href, title, text);
+        renderer.image = (href, title, text) => this.image(href, title, text);
+        renderer.heading = (text, level, raw) => this.heading(text, level, raw);
+        this._markedRenderer = renderer;
+    }
+    async click(event, containerElement) {
+        console.debug('[markdown-service] Processing click event...', event);
+        const element = event.target;
+        if (!(element instanceof HTMLAnchorElement)) {
+            return;
+        }
+        let href = element.getAttribute('href');
+        const fragment = UrlUtils.getFragment(href);
+        // Fragment
+        if (href?.startsWith('#') && isNotNilOrBlank(fragment)) {
+            event.preventDefault();
+            this.scrollToAnchor(containerElement, fragment);
+            return true;
+        }
+        const routerLink = element.getAttribute('routerLink');
+        if (routerLink) {
+            event.preventDefault();
+            return this.navController.navigateForward(routerLink);
+        }
+        // Resolve relative URL, if baseUrl has been set
+        if (this.baseUrl && UrlUtils.isRelativeUrl(href)) {
+            if (MarkdownUtils.isMarkdownFile(href) && this.onClickMarkdownUrl.observed) {
+                event.preventDefault();
+                this.onClickMarkdownUrl.next(href);
+                return true;
+            }
+            // Resolve URL, then open using the platform
+            href = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href);
+        }
+        // Resolve internal URL as an app route
+        if (UrlUtils.isInternalUrl(href)) {
+            const routePath = this.normalizeUrl(href.startsWith('/') ? href : `/${href}`);
+            const urlTree = this.getUrlTree(routePath);
+            event.preventDefault();
+            this.router.navigated = false;
+            // Opening route
+            return this.navController.navigateForward(urlTree);
+        }
+        // External URL: open using the platform
+        event.preventDefault();
+        await this.platform.open(href);
+        return true;
+    }
+    link(href, title, text) {
+        if (UrlUtils.isInternalUrl(href) && !href.startsWith('#') && !this.baseUrl) {
+            const externalUrl = this.normalizeUrl(href);
+            return `<a href="${externalUrl}" routerLink="${href}" title="${title || ''}">${text}</a>`;
+        }
+        return `<a href="${href || ''}" title="${title || ''}">${text}</a>`;
+    }
+    image(href, title, text) {
+        let url = href;
+        let fallbackUrl;
+        if (UrlUtils.isRelativeUrl(href) && this.baseUrl) {
+            // Resolve relative path
+            url = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href);
+            // Compute a fallback URL
+            fallbackUrl = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href, { absoluteByDefault: true });
+            fallbackUrl = fallbackUrl === url ? null : fallbackUrl;
+            // DEBUG
+            console.debug(`[markdown-service] Replacing image: ${href} -> ${url}`);
+            if (fallbackUrl) {
+                const fallbackHtml = `<img src="${fallbackUrl}" title="${title || ''}" alt="${text}" onerror="this.style.display='none';" />`;
+                return `<img src="${url}" title="${title || ''}" alt="${text}" onerror="this.style.display='none';" />` + fallbackHtml;
+            }
+            else {
+                return this._defaultRenderer.image(url, title, text);
+            }
+        }
+        return this._defaultRenderer.image(url, title, text);
+    }
+    heading(text, level, raw) {
+        // If NOT the h1 (document title)
+        const anchor = MarkdownUtils.textToAnchor(text);
+        if (isNotNilOrBlank(anchor)) {
+            console.debug(`[markdown-service] Heading ${level} '${text}' with anchor ${anchor}`);
+            const link = `<a id="${anchor}" class="anchor" aria-hidden="true" href="#${anchor}"></a>`;
+            return this._defaultRenderer.heading(link + text, level, raw);
+        }
+        return this._defaultRenderer.heading(text, level, raw);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown.service.js","sourceRoot":"","sources":["../../../../../../src/app/shared/markdown/markdown.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { ActivatedRoute, Router, UrlTree } from '@angular/router';\nimport { ModalController, NavController } from '@ionic/angular';\nimport { LocationStrategy } from '@angular/common';\nimport { MarkedRenderer } from 'ngx-markdown';\nimport { UrlUtils } from '../file/url.utils';\nimport { Subject, Subscription } from 'rxjs';\nimport { isNotNilOrBlank } from '../functions';\nimport { MarkdownUtils } from './markdown.utils';\nimport { PlatformService } from '../../core/services/platform.service';\n\n@Injectable({ providedIn: 'root' })\nexport class MarkdownService {\n  private route = inject(ActivatedRoute);\n  private router = inject(Router);\n  private platform = inject(PlatformService);\n  private locationStrategy = inject(LocationStrategy);\n  private navController = inject(NavController);\n  private modalCtrl = inject(ModalController);\n\n  private baseUrl: string;\n\n  private readonly _defaultRenderer = new MarkedRenderer();\n  private _markedRenderer: MarkedRenderer;\n\n  get renderer(): MarkedRenderer {\n    return this._markedRenderer;\n  }\n\n  set renderer(value: MarkedRenderer) {\n    this.setRenderer(value);\n  }\n\n  onClickMarkdownUrl = new Subject<string>();\n\n  constructor() {\n    this.setRenderer(new MarkedRenderer());\n  }\n\n  setBaseUrl(baseUrl: string) {\n    console.debug('[markdown-service] Base URL: ' + baseUrl);\n    this.baseUrl = baseUrl;\n  }\n\n  resetBaseUrl() {\n    this.setBaseUrl(null);\n  }\n\n  getUrlTree(url: string): UrlTree {\n    url = UrlUtils.normalizeUrl(url);\n    const urlPath = UrlUtils.stripFragmentAndQuery(url) || UrlUtils.stripFragmentAndQuery(this.router.url);\n    const parsedUrl = this.router.parseUrl(url);\n    const fragment = parsedUrl.fragment;\n    const queryParams = parsedUrl.queryParams;\n    return this.router.createUrlTree([urlPath], { relativeTo: this.route, fragment, queryParams });\n  }\n\n  navigate(url: string, replaceUrl = false) {\n    const urlTree = this.getUrlTree(url);\n    this.router.navigated = false;\n    this.navController.navigateForward(urlTree, { replaceUrl });\n  }\n\n  listenClickEvents(nativeElement: HTMLElement): Subscription {\n    console.debug('[markdown-service] Start listening click events...');\n    const subscription = new Subscription();\n    const listener = (event: Event) => this.click(event, nativeElement);\n    const links = nativeElement.querySelectorAll('a');\n    links.forEach((link) => {\n      // DEBUG\n      //console.debug('[markdown-service] Adding click listener to', link);\n      link.addEventListener('click', listener);\n      subscription.add(() => link.removeEventListener('click', listener));\n    });\n\n    // DEBUG\n    subscription.add(() => console.debug('[markdown-service] Stop listening click events'));\n\n    return subscription;\n  }\n\n  /**\n   * Transform a relative URL to its absolute representation according to current router state.\n   * @param url Relative URL path.\n   * @return Absolute URL based on the current route.\n   */\n  normalizeUrl(url: string): string {\n    if (UrlUtils.isExternalUrl(url)) {\n      return url;\n    }\n    if (this.baseUrl && UrlUtils.isRelativeUrl(url)) {\n      return MarkdownUtils.resolveRelativeUrl(this.baseUrl, url);\n    }\n\n    const urlTree = this.getUrlTree(url);\n    const serializedUrl = this.router.serializeUrl(urlTree);\n    return this.locationStrategy.prepareExternalUrl(serializedUrl);\n  }\n\n  scrollToAnchor(containerElement: HTMLElement, anchorId: string) {\n    if (!containerElement || !anchorId) {\n      console.warn(\"Missing 'containerElement' or 'fragment' argument.\");\n      return;\n    }\n\n    console.debug('[markdown-anchor] Scrolling to anchor #' + anchorId);\n\n    // Find the target element with the specified fragment ID\n    let targetElement = containerElement.querySelector(`#${anchorId}`);\n\n    // If not found, retry fix a fixed anchor id. This can occur when ToC has been generated for the maven-markdown-plugin\n    if (!targetElement) {\n      targetElement = containerElement.querySelector(`#${MarkdownUtils.fixAnchor(anchorId)}`);\n    }\n\n    if (targetElement) {\n      // Scroll smoothly to the target element\n      targetElement.scrollIntoView({\n        behavior: 'smooth', // Smooth scrolling behavior\n        block: 'start', // Align the target element to the top of the container\n      });\n    } else {\n      console.warn(`No element found with the ID \"${anchorId}\" inside the container.`);\n    }\n  }\n\n  /* -- protected function -- */\n\n  protected setRenderer(renderer: MarkedRenderer) {\n    console.debug('[markdown-service] Set renderer', renderer);\n    renderer.link = (href, title, text) => this.link(href, title, text);\n    renderer.image = (href, title, text) => this.image(href, title, text);\n    renderer.heading = (text, level, raw) => this.heading(text, level, raw);\n    this._markedRenderer = renderer;\n  }\n\n  protected async click(event: Event, containerElement: HTMLElement): Promise<boolean> {\n    console.debug('[markdown-service] Processing click event...', event);\n\n    const element = event.target;\n    if (!(element instanceof HTMLAnchorElement)) {\n      return;\n    }\n\n    let href = element.getAttribute('href');\n    const fragment = UrlUtils.getFragment(href);\n\n    // Fragment\n    if (href?.startsWith('#') && isNotNilOrBlank(fragment)) {\n      event.preventDefault();\n      this.scrollToAnchor(containerElement, fragment);\n      return true;\n    }\n\n    const routerLink = element.getAttribute('routerLink');\n    if (routerLink) {\n      event.preventDefault();\n      return this.navController.navigateForward(routerLink);\n    }\n\n    // Resolve relative URL, if baseUrl has been set\n    if (this.baseUrl && UrlUtils.isRelativeUrl(href)) {\n      if (MarkdownUtils.isMarkdownFile(href) && this.onClickMarkdownUrl.observed) {\n        event.preventDefault();\n        this.onClickMarkdownUrl.next(href);\n        return true;\n      }\n\n      // Resolve URL, then open using the platform\n      href = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href);\n    }\n\n    // Resolve internal URL as an app route\n    if (UrlUtils.isInternalUrl(href)) {\n      const routePath = this.normalizeUrl(href.startsWith('/') ? href : `/${href}`);\n      const urlTree = this.getUrlTree(routePath);\n      event.preventDefault();\n      this.router.navigated = false;\n      // Opening route\n      return this.navController.navigateForward(urlTree);\n    }\n\n    // External URL: open using the platform\n    event.preventDefault();\n    await this.platform.open(href);\n    return true;\n  }\n\n  protected link(href: string | null, title: string | null, text: string): string {\n    if (UrlUtils.isInternalUrl(href) && !href.startsWith('#') && !this.baseUrl) {\n      const externalUrl = this.normalizeUrl(href);\n      return `<a href=\"${externalUrl}\" routerLink=\"${href}\" title=\"${title || ''}\">${text}</a>`;\n    }\n    return `<a href=\"${href || ''}\" title=\"${title || ''}\">${text}</a>`;\n  }\n\n  protected image(href: string, title: string | null, text: string): string {\n    let url = href;\n    let fallbackUrl: string;\n    if (UrlUtils.isRelativeUrl(href) && this.baseUrl) {\n      // Resolve relative path\n      url = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href);\n\n      // Compute a fallback URL\n      fallbackUrl = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href, { absoluteByDefault: true });\n      fallbackUrl = fallbackUrl === url ? null : fallbackUrl;\n\n      // DEBUG\n      console.debug(`[markdown-service] Replacing image: ${href} -> ${url}`);\n\n      if (fallbackUrl) {\n        const fallbackHtml = `<img src=\"${fallbackUrl}\" title=\"${title || ''}\" alt=\"${text}\" onerror=\"this.style.display='none';\" />`;\n        return `<img src=\"${url}\" title=\"${title || ''}\" alt=\"${text}\" onerror=\"this.style.display='none';\" />` + fallbackHtml;\n      } else {\n        return this._defaultRenderer.image(url, title, text);\n      }\n    }\n    return this._defaultRenderer.image(url, title, text);\n  }\n\n  protected heading(text: string, level: number, raw: string): string {\n    // If NOT the h1 (document title)\n    const anchor = MarkdownUtils.textToAnchor(text);\n    if (isNotNilOrBlank(anchor)) {\n      console.debug(`[markdown-service] Heading ${level} '${text}' with anchor ${anchor}`);\n      const link = `<a id=\"${anchor}\" class=\"anchor\" aria-hidden=\"true\" href=\"#${anchor}\"></a>`;\n      return this._defaultRenderer.heading(link + text, level, raw);\n    }\n    return this._defaultRenderer.heading(text, level, raw);\n  }\n}\n"]}

package/esm2022/src/app/shared/markdown/markdown.utils.mjs

@@ -0,0 +1,78 @@
+import { UriUtils } from '../file/uri.utils';
+import { UrlUtils } from '../file/url.utils';
+export class MarkdownUtils {
+    static HTML_ENTITIES_MAP = {
+        ''': "'", // Single quote
+        '"': '"', // Double quote
+        '&': '&', // Ampersand
+        '&lt;': '<', // Less-than
+        '&gt;': '>', // Greater-than
+        '&nbsp;': ' ', // Non-breaking space
+        // Add more entities here if needed
+    };
+    /**
+     * Converts the given text into a valid anchor-compatible format.
+     *
+     * @param {string} text - The input text to be transformed into an anchor.
+     * @return {string} The formatted string suitable for use as an anchor.
+     */
+    static textToAnchor(text) {
+        if (!text)
+            return '';
+        return (text
+            .toLowerCase()
+            .trim()
+            // Replace entities
+            .replace(/&#?[a-z0-9]+;/g, (entity) => this.HTML_ENTITIES_MAP[entity] || '')
+            .replace(/['"&<>=\\()]+/g, '')
+            .replace(/\s/g, '-')
+            .replace(/^-|-$/g, '-'));
+    }
+    /**
+     * Adjusts the given anchor ID by replacing underscores with hyphens and converting to lowercase.
+     *
+     * @param {string} anchorId - The anchor ID string to be fixed.
+     * @return {string} The modified anchor ID with underscores replaced by hyphens and converted to lowercase, or the original anchor ID if it is falsy.
+     */
+    static fixAnchor(anchorId) {
+        if (!anchorId)
+            return anchorId;
+        return anchorId.replace(/_/g, '-').toLowerCase();
+    }
+    static isMarkdownFile(url) {
+        const cleanUrl = UrlUtils.stripFragmentAndQuery(url);
+        const filename = UriUtils.getFilename(cleanUrl);
+        return filename.endsWith('.md');
+    }
+    static resolveRelativeUrl(baseUrl, relativePath, opts) {
+        if (!baseUrl)
+            throw new Error("Argument 'baseUrl' is missing");
+        if (!relativePath)
+            throw new Error("Argument 'relativePath' is missing");
+        if (!UrlUtils.isRelativeUrl(relativePath))
+            throw new Error('Should be a relative path');
+        // Detect absolute URL
+        if (relativePath.startsWith('/') || (opts?.absoluteByDefault && !relativePath.startsWith('.'))) {
+            baseUrl = this.getRootUrl(baseUrl);
+            relativePath = relativePath.startsWith('/') ? relativePath.substring(1) : relativePath;
+        }
+        return UrlUtils.normalizeUrl(UrlUtils.concat(baseUrl, relativePath));
+    }
+    static isGitlabUrl(url) {
+        return url.startsWith('https://gitlab.') || url.includes('/-/raw/') || url.includes('/-/blob/');
+    }
+    static getRootUrl(url) {
+        if (this.isGitlabUrl(url)) {
+            console.debug('[markdown] Gitlab URL detected: ' + url);
+            url = url.replace('/-/blob/', '/-/raw/');
+            if (url.includes('/-/raw/')) {
+                const index = url.indexOf('/-/raw/') + '/-/raw/'.length;
+                const rootPath = url.substring(0, index);
+                const branch = url.substring(index).split('/', 2)[0];
+                return rootPath + branch;
+            }
+        }
+        return UrlUtils.getRootUrl(url);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/shared/markdown/testing/markdown.test.mjs

@@ -0,0 +1,45 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { AppMarkdownModal } from '../markdown.modal';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@angular/forms";
+import * as i3 from "../markdown.component";
+import * as i4 from "@ngx-translate/core";
+export class MarkdownTestPage {
+    modalCtrl;
+    cd;
+    markdownModalTitle = 'Markdown modal';
+    // URL from a starting markdown
+    markdownUrl = 'http://localhost:3000/user-manual/index.md';
+    //protected markdownUrl = 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/raw/master/projects/pifil/man/quick_start_guide_fr.md';
+    //protected markdownUrl = 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/raw/master/README.md';
+    //protected markdownUrl = 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/raw/master/model/index.md';
+    //protected markdownUrl = 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/raw/master/model/administration/index.md';
+    //protected markdownUrl ='https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/raw/master/projects/activity-calendar/spe/collecte_de_donnees.md';
+    //protected markdownUrl ='https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/raw/develop/doc/privacy_policy.md';
+    constructor(modalCtrl, cd) {
+        this.modalCtrl = modalCtrl;
+        this.cd = cd;
+    }
+    onSubmit(event, newUrl) {
+        this.markdownUrl = '' + newUrl;
+        this.cd.markForCheck();
+    }
+    updateInputUrl(url) {
+        this.markdownUrl = url;
+        this.cd.markForCheck();
+    }
+    openHelpModal(event) {
+        return AppMarkdownModal.show(this.modalCtrl, {
+            title: this.markdownModalTitle,
+            markdownUrl: this.markdownUrl,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownTestPage, deps: [{ token: i1.ModalController }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: MarkdownTestPage, selector: "app-markdown-test", ngImport: i0, template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      @if (content.canGoBack) {\n        <ion-button class=\"back-button\" (click)=\"content.goBack($event)\" routerDirection=\"back\">\n          <ion-icon slot=\"icon-only\" name=\"arrow-back\"></ion-icon>\n        </ion-button>\n      } @else {\n        <ion-back-button></ion-back-button>\n      }\n    </ion-buttons>\n\n    <ion-title>Markdown test page</ion-title>\n\n    <ion-buttons slot=\"end\">\n      <ion-button (click)=\"openHelpModal($event)\">Open in modal</ion-button>\n    </ion-buttons>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content class=\"ion-padding\">\n  <ion-input\n    #input\n    fill=\"outline\"\n    [ngModel]=\"markdownUrl\"\n    placeholder=\"Markdown URL\"\n    label=\"URL: \"\n    (keyup.enter)=\"onSubmit($event, input.value)\"\n  >\n    <ion-button\n      slot=\"end\"\n      [fill]=\"markdownUrl !== input.value ? 'solid' : 'clear'\"\n      (click)=\"onSubmit($event, input.value)\"\n    >\n      {{ 'COMMON.BTN_OK' | translate }}\n    </ion-button>\n  </ion-input>\n\n  <app-markdown-content\n    #content\n    [src]=\"markdownUrl\"\n    enableNavigationHistory=\"true\"\n    debug=\"true\"\n    (markdownUrlChange)=\"updateInputUrl($event)\"\n  ></app-markdown-content>\n</ion-content>\n", dependencies: [{ kind: "component", type: i1.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i1.IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: i1.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i1.IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: i1.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i1.IonInput, selector: "ion-input", inputs: ["accept", "autocapitalize", "autocomplete", "autocorrect", "autofocus", "clearInput", "clearOnEdit", "color", "counter", "counterFormatter", "debounce", "disabled", "enterkeyhint", "errorText", "fill", "helperText", "inputmode", "label", "labelPlacement", "legacy", "max", "maxlength", "min", "minlength", "mode", "multiple", "name", "pattern", "placeholder", "readonly", "required", "shape", "size", "spellcheck", "step", "type", "value"] }, { kind: "component", type: i1.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i1.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "directive", type: i1.TextValueAccessor, selector: "ion-input:not([type=number]),ion-textarea,ion-searchbar,ion-range" }, { kind: "component", type: i1.IonBackButton, selector: "ion-back-button" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "component", type: i3.AppMarkdownContent, selector: "app-markdown-content", inputs: ["data", "src", "anchor", "debug", "showError", "animated", "enableNavigationHistory", "updateRouteLocation"], outputs: ["markdownUrlChange"] }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownTestPage, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-markdown-test', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      @if (content.canGoBack) {\n        <ion-button class=\"back-button\" (click)=\"content.goBack($event)\" routerDirection=\"back\">\n          <ion-icon slot=\"icon-only\" name=\"arrow-back\"></ion-icon>\n        </ion-button>\n      } @else {\n        <ion-back-button></ion-back-button>\n      }\n    </ion-buttons>\n\n    <ion-title>Markdown test page</ion-title>\n\n    <ion-buttons slot=\"end\">\n      <ion-button (click)=\"openHelpModal($event)\">Open in modal</ion-button>\n    </ion-buttons>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content class=\"ion-padding\">\n  <ion-input\n    #input\n    fill=\"outline\"\n    [ngModel]=\"markdownUrl\"\n    placeholder=\"Markdown URL\"\n    label=\"URL: \"\n    (keyup.enter)=\"onSubmit($event, input.value)\"\n  >\n    <ion-button\n      slot=\"end\"\n      [fill]=\"markdownUrl !== input.value ? 'solid' : 'clear'\"\n      (click)=\"onSubmit($event, input.value)\"\n    >\n      {{ 'COMMON.BTN_OK' | translate }}\n    </ion-button>\n  </ion-input>\n\n  <app-markdown-content\n    #content\n    [src]=\"markdownUrl\"\n    enableNavigationHistory=\"true\"\n    debug=\"true\"\n    (markdownUrlChange)=\"updateInputUrl($event)\"\n  ></app-markdown-content>\n</ion-content>\n" }]
+        }], ctorParameters: () => [{ type: i1.ModalController }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/shared/markdown/testing/markdown.testing.module.mjs

@@ -0,0 +1,29 @@
+import { RouterModule } from '@angular/router';
+import { SharedModule } from '../../shared.module';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MarkdownTestPage } from './markdown.test';
+import { FormsModule } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const routes = [
+    {
+        path: 'markdown',
+        pathMatch: 'full',
+        component: MarkdownTestPage,
+    },
+];
+export class MarkdownTestingModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MarkdownTestingModule, declarations: [MarkdownTestPage], imports: [CommonModule, i1.RouterModule, SharedModule, FormsModule], exports: [RouterModule, MarkdownTestPage] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownTestingModule, imports: [CommonModule, RouterModule.forChild(routes), SharedModule, FormsModule, RouterModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, RouterModule.forChild(routes), SharedModule, FormsModule],
+                    declarations: [MarkdownTestPage],
+                    exports: [RouterModule, MarkdownTestPage],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/shared/material/material.animations.mjs

@@ -140,4 +140,34 @@ trigger('slideUpDownAnimation', [
         })),
     ]),
 ]);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material.animations.js","sourceRoot":"","sources":["../../../../../../src/app/shared/material/material.animations.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEjF,MAAM,CAAC,MAAM,eAAe;AAC1B,0FAA0F;AAC1F,OAAO,CAAC,iBAAiB,EAAE;IACzB,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,oCAAoC;QACpC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;QAErB,4CAA4C;QAC5C,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;KACtC,CAAC;CACH,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,mBAAmB,GAAG,OAAO,CAAC,qBAAqB,EAAE;IAChE,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,oCAAoC;QACpC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;QAErB,4CAA4C;QAC5C,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;KACtC,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB;AAC7B,0FAA0F;AAC1F,OAAO,CAAC,oBAAoB,EAAE;IAC5B,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,oCAAoC;QACpC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;QAErB,4CAA4C;QAC5C,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;KACtC,CAAC;IAEF,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,4CAA4C;QAC5C,OAAO,CACL,iBAAiB,EACjB,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC;SACX,CAAC,CACH;KACF,CAAC;CACH,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAC1D,8CAA8C;IAC9C,KAAK,CACH,GAAG,EACH,KAAK,CAAC;QACJ,qEAAqE;QACrE,QAAQ,EAAE,UAAU;QACpB,GAAG,EAAE,CAAC;QACN,IAAI,EAAE,CAAC;QACP,KAAK,EAAE,CAAC;QACR,MAAM,EAAE,CAAC;QACT,OAAO,EAAE,CAAC;KACX,CAAC,CACH;IAED,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,gCAAgC;QAChC,KAAK,CAAC;YACJ,iEAAiE;YACjE,oGAAoG;YACpG,IAAI,EAAE,MAAM;YAEZ,qDAAqD;YACrD,OAAO,EAAE,CAAC;SACX,CAAC;QAEF,4CAA4C;QAC5C,OAAO,CACL,iBAAiB,EACjB,KAAK,CAAC;YACJ,wEAAwE;YACxE,IAAI,EAAE,CAAC;YAEP,yDAAyD;YACzD,OAAO,EAAE,GAAG;SACb,CAAC,CACH;KACF,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,mBAAmB;AAC9B,0FAA0F;AAC1F,OAAO,CAAC,qBAAqB,EAAE;IAC7B,8CAA8C;IAC9C,KAAK,CACH,GAAG,EACH,KAAK,CAAC;QACJ,qEAAqE;QACrE,QAAQ,EAAE,UAAU;QACpB,GAAG,EAAE,CAAC;QACN,IAAI,EAAE,CAAC;QACP,KAAK,EAAE,CAAC;QACR,MAAM,EAAE,CAAC;QACT,OAAO,EAAE,CAAC;KACX,CAAC,CACH;IAED,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,gCAAgC;QAChC,KAAK,CAAC;YACJ,iEAAiE;YACjE,oGAAoG;YACpG,IAAI,EAAE,MAAM;YAEZ,qDAAqD;YACrD,OAAO,EAAE,CAAC;SACX,CAAC;QAEF,4CAA4C;QAC5C,OAAO,CACL,iBAAiB,EACjB,KAAK,CAAC;YACJ,wEAAwE;YACxE,IAAI,EAAE,CAAC;YAEP,yDAAyD;YACzD,OAAO,EAAE,GAAG;SACb,CAAC,CACH;KACF,CAAC;IAEF,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,4CAA4C;QAC5C,OAAO,CACL,iBAAiB,EACjB,KAAK,CAAC;YACJ,8EAA8E;YAC9E,IAAI,EAAE,MAAM;YAEZ,wDAAwD;YACxD,OAAO,EAAE,CAAC;SACX,CAAC,CACH;KACF,CAAC;CACH,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,oBAAoB;AAC/B,0FAA0F;AAC1F,OAAO,CAAC,sBAAsB,EAAE;IAC9B,8CAA8C;IAC9C,KAAK,CACH,GAAG,EACH,KAAK,CAAC;QACJ,SAAS,EAAE,eAAe;QAC1B,OAAO,EAAE,CAAC;KACX,CAAC,CACH;IAED,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,gCAAgC;QAChC,KAAK,CAAC;YACJ,SAAS,EAAE,mBAAmB;YAC9B,OAAO,EAAE,CAAC;SACX,CAAC;QAEF,4CAA4C;QAC5C,OAAO,CACL,iBAAiB,EACjB,KAAK,CAAC;YACJ,SAAS,EAAE,eAAe;YAC1B,OAAO,EAAE,CAAC;SACX,CAAC,CACH;KACF,CAAC;IAEF,2BAA2B;IAC3B,UAAU,CAAC,QAAQ,EAAE;QACnB,4CAA4C;QAC5C,OAAO,CACL,iBAAiB,EACjB,KAAK,CAAC;YACJ,SAAS,EAAE,mBAAmB;YAC9B,OAAO,EAAE,CAAC;SACX,CAAC,CACH;KACF,CAAC;CACH,CAAC,CAAC","sourcesContent":["// import the required animation functions from the angular animations module\nimport { animate, state, style, transition, trigger } from '@angular/animations';\n\nexport const fadeInAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('fadeInAnimation', [\n    // route 'enter' transition\n    transition(':enter', [\n      // css styles at start of transition\n      style({ opacity: 0 }),\n\n      // animation and styles at end of transition\n      animate('.3s', style({ opacity: 1 })),\n    ]),\n  ]);\n\nexport const fadeInSlowAnimation = trigger('fadeInSlowAnimation', [\n  // route 'enter' transition\n  transition(':enter', [\n    // css styles at start of transition\n    style({ opacity: 0 }),\n\n    // animation and styles at end of transition\n    animate('.5s', style({ opacity: 1 })),\n  ]),\n]);\n\nexport const fadeInOutAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('fadeInOutAnimation', [\n    // route 'enter' transition\n    transition(':enter', [\n      // css styles at start of transition\n      style({ opacity: 0 }),\n\n      // animation and styles at end of transition\n      animate('.3s', style({ opacity: 1 })),\n    ]),\n\n    // route 'leave' transition\n    transition(':leave', [\n      // animation and styles at end of transition\n      animate(\n        '.5s ease-in-out',\n        style({\n          opacity: 0,\n        })\n      ),\n    ]),\n  ]);\n\nexport const slideInAnimation = trigger('slideInAnimation', [\n  // end state styles for route container (host)\n  state(\n    '*',\n    style({\n      // the view covers the whole screen with a semi tranparent background\n      position: 'relative',\n      top: 0,\n      left: 0,\n      right: 0,\n      bottom: 0,\n      opacity: 1,\n    })\n  ),\n\n  // route 'enter' transition\n  transition(':enter', [\n    // styles at start of transition\n    style({\n      // start with the content positioned off the right of the screen,\n      // -400% is required instead of -100% because the negative position adds to the width of the element\n      left: '400%',\n\n      // start with background opacity set to 0 (invisible)\n      opacity: 0,\n    }),\n\n    // animation and styles at end of transition\n    animate(\n      '.3s ease-in-out',\n      style({\n        // transition the right position to 0 which slides the content into view\n        left: 0,\n\n        // transition the background opacity to 0.8 to fade it in\n        opacity: 0.8,\n      })\n    ),\n  ]),\n]);\n\nexport const slideInOutAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('slideInOutAnimation', [\n    // end state styles for route container (host)\n    state(\n      '*',\n      style({\n        // the view covers the whole screen with a semi tranparent background\n        position: 'relative',\n        top: 0,\n        left: 0,\n        right: 0,\n        bottom: 0,\n        opacity: 1,\n      })\n    ),\n\n    // route 'enter' transition\n    transition(':enter', [\n      // styles at start of transition\n      style({\n        // start with the content positioned off the right of the screen,\n        // -400% is required instead of -100% because the negative position adds to the width of the element\n        left: '400%',\n\n        // start with background opacity set to 0 (invisible)\n        opacity: 0,\n      }),\n\n      // animation and styles at end of transition\n      animate(\n        '.3s ease-in-out',\n        style({\n          // transition the right position to 0 which slides the content into view\n          left: 0,\n\n          // transition the background opacity to 0.8 to fade it in\n          opacity: 0.8,\n        })\n      ),\n    ]),\n\n    // route 'leave' transition\n    transition(':leave', [\n      // animation and styles at end of transition\n      animate(\n        '.5s ease-in-out',\n        style({\n          // transition the right position to -400% which slides the content out of view\n          left: '400%',\n\n          // transition the background opacity to 0 to fade it out\n          opacity: 0,\n        })\n      ),\n    ]),\n  ]);\n\nexport const slideUpDownAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('slideUpDownAnimation', [\n    // end state styles for route container (host)\n    state(\n      '*',\n      style({\n        transform: 'translateY(0)',\n        opacity: 1,\n      })\n    ),\n\n    // route 'enter' transition\n    transition(':enter', [\n      // styles at start of transition\n      style({\n        transform: 'translateY(-400%)',\n        opacity: 0,\n      }),\n\n      // animation and styles at end of transition\n      animate(\n        '.3s ease-in-out',\n        style({\n          transform: 'translateY(0)',\n          opacity: 1,\n        })\n      ),\n    ]),\n\n    // route 'leave' transition\n    transition(':leave', [\n      // animation and styles at end of transition\n      animate(\n        '.5s ease-in-out',\n        style({\n          transform: 'translateY(-400%)',\n          opacity: 0,\n        })\n      ),\n    ]),\n  ]);\n"]}
+export const slideDownAnimation = 
+// trigger name for attaching this animation to an element using the [@triggerName] syntax
+trigger('slideDownAnimation', [
+    // end state styles for route container (host)
+    state('*', style({
+        transform: 'translateY(0)',
+        opacity: 1,
+    })),
+    // route 'enter' transition
+    transition(':enter', [
+        // styles at start of transition
+        style({
+            transform: 'translateY(-400%)',
+            opacity: 0,
+        }),
+        // animation and styles at end of transition
+        animate('.3s ease-in-out', style({
+            transform: 'translateY(0)',
+            opacity: 1,
+        })),
+    ]),
+    // route 'leave' transition
+    transition(':leave', [
+        // animation and styles at end of transition
+        style({
+            transform: 'translateY(-400%)',
+            opacity: 0,
+        }),
+    ]),
+]);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material.animations.js","sourceRoot":"","sources":["../../../../../../src/app/shared/material/material.animations.ts"],"names":[],"mappings":"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","sourcesContent":["// import the required animation functions from the angular animations module\nimport { animate, state, style, transition, trigger } from '@angular/animations';\n\nexport const fadeInAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('fadeInAnimation', [\n    // route 'enter' transition\n    transition(':enter', [\n      // css styles at start of transition\n      style({ opacity: 0 }),\n\n      // animation and styles at end of transition\n      animate('.3s', style({ opacity: 1 })),\n    ]),\n  ]);\n\nexport const fadeInSlowAnimation = trigger('fadeInSlowAnimation', [\n  // route 'enter' transition\n  transition(':enter', [\n    // css styles at start of transition\n    style({ opacity: 0 }),\n\n    // animation and styles at end of transition\n    animate('.5s', style({ opacity: 1 })),\n  ]),\n]);\n\nexport const fadeInOutAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('fadeInOutAnimation', [\n    // route 'enter' transition\n    transition(':enter', [\n      // css styles at start of transition\n      style({ opacity: 0 }),\n\n      // animation and styles at end of transition\n      animate('.3s', style({ opacity: 1 })),\n    ]),\n\n    // route 'leave' transition\n    transition(':leave', [\n      // animation and styles at end of transition\n      animate(\n        '.5s ease-in-out',\n        style({\n          opacity: 0,\n        })\n      ),\n    ]),\n  ]);\n\nexport const slideInAnimation = trigger('slideInAnimation', [\n  // end state styles for route container (host)\n  state(\n    '*',\n    style({\n      // the view covers the whole screen with a semi tranparent background\n      position: 'relative',\n      top: 0,\n      left: 0,\n      right: 0,\n      bottom: 0,\n      opacity: 1,\n    })\n  ),\n\n  // route 'enter' transition\n  transition(':enter', [\n    // styles at start of transition\n    style({\n      // start with the content positioned off the right of the screen,\n      // -400% is required instead of -100% because the negative position adds to the width of the element\n      left: '400%',\n\n      // start with background opacity set to 0 (invisible)\n      opacity: 0,\n    }),\n\n    // animation and styles at end of transition\n    animate(\n      '.3s ease-in-out',\n      style({\n        // transition the right position to 0 which slides the content into view\n        left: 0,\n\n        // transition the background opacity to 0.8 to fade it in\n        opacity: 0.8,\n      })\n    ),\n  ]),\n]);\n\nexport const slideInOutAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('slideInOutAnimation', [\n    // end state styles for route container (host)\n    state(\n      '*',\n      style({\n        // the view covers the whole screen with a semi tranparent background\n        position: 'relative',\n        top: 0,\n        left: 0,\n        right: 0,\n        bottom: 0,\n        opacity: 1,\n      })\n    ),\n\n    // route 'enter' transition\n    transition(':enter', [\n      // styles at start of transition\n      style({\n        // start with the content positioned off the right of the screen,\n        // -400% is required instead of -100% because the negative position adds to the width of the element\n        left: '400%',\n\n        // start with background opacity set to 0 (invisible)\n        opacity: 0,\n      }),\n\n      // animation and styles at end of transition\n      animate(\n        '.3s ease-in-out',\n        style({\n          // transition the right position to 0 which slides the content into view\n          left: 0,\n\n          // transition the background opacity to 0.8 to fade it in\n          opacity: 0.8,\n        })\n      ),\n    ]),\n\n    // route 'leave' transition\n    transition(':leave', [\n      // animation and styles at end of transition\n      animate(\n        '.5s ease-in-out',\n        style({\n          // transition the right position to -400% which slides the content out of view\n          left: '400%',\n\n          // transition the background opacity to 0 to fade it out\n          opacity: 0,\n        })\n      ),\n    ]),\n  ]);\n\nexport const slideUpDownAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('slideUpDownAnimation', [\n    // end state styles for route container (host)\n    state(\n      '*',\n      style({\n        transform: 'translateY(0)',\n        opacity: 1,\n      })\n    ),\n\n    // route 'enter' transition\n    transition(':enter', [\n      // styles at start of transition\n      style({\n        transform: 'translateY(-400%)',\n        opacity: 0,\n      }),\n\n      // animation and styles at end of transition\n      animate(\n        '.3s ease-in-out',\n        style({\n          transform: 'translateY(0)',\n          opacity: 1,\n        })\n      ),\n    ]),\n\n    // route 'leave' transition\n    transition(':leave', [\n      // animation and styles at end of transition\n      animate(\n        '.5s ease-in-out',\n        style({\n          transform: 'translateY(-400%)',\n          opacity: 0,\n        })\n      ),\n    ]),\n  ]);\n\nexport const slideDownAnimation =\n  // trigger name for attaching this animation to an element using the [@triggerName] syntax\n  trigger('slideDownAnimation', [\n    // end state styles for route container (host)\n    state(\n      '*',\n      style({\n        transform: 'translateY(0)',\n        opacity: 1,\n      })\n    ),\n\n    // route 'enter' transition\n    transition(':enter', [\n      // styles at start of transition\n      style({\n        transform: 'translateY(-400%)',\n        opacity: 0,\n      }),\n\n      // animation and styles at end of transition\n      animate(\n        '.3s ease-in-out',\n        style({\n          transform: 'translateY(0)',\n          opacity: 1,\n        })\n      ),\n    ]),\n\n    // route 'leave' transition\n    transition(':leave', [\n      // animation and styles at end of transition\n      style({\n        transform: 'translateY(-400%)',\n        opacity: 0,\n      }),\n    ]),\n  ]);\n"]}

package/esm2022/src/app/shared/pipes/pipes.module.mjs

@@ -22,7 +22,7 @@ import { AsAnyPipe, AsArrayPipe, AsBooleanPipe, AsFloatLabelTypePipe, AsObservab
 import { MaskitoPlaceholderPipe } from './maskito.pipe';
 import { IsEmptySelectionPipe, IsMultipleSelectionPipe, IsNotEmptySelectionPipe, IsSelectedPipe, IsSingleSelectionPipe, SelectionLengthPipe, } from './selection.pipes';
 import { BadgeNumberPipe } from './badge.pipes';
-import { CapitalizePipe, IsNilOrBlankPipe, IsNilOrNaNPipe, IsNilPipe, IsNotNilOrBlankPipe, IsNotNilOrNaNPipe, IsNotNilPipe, StrIncludesPipe, StrLengthPipe, ToStringPipe, } from './string.pipes';
+import { CapitalizePipe, IsNilOrBlankPipe, IsNilOrNaNPipe, IsNilPipe, IsNotNilOrBlankPipe, IsNotNilOrNaNPipe, IsNotNilPipe, StrIncludesPipe, StrLengthPipe, StrReplacePipe, ToStringPipe, } from './string.pipes';
 import { NoHtmlPipe, SafeHtmlPipe } from './html.pipes';
 import { DisplayWithPipe } from './display-with.pipe';
 import { IsValidDatePipe } from './dates.pipe';
@@ -67,6 +67,7 @@ const components = [
     CapitalizePipe,
     StrLengthPipe,
     StrIncludesPipe,
+    StrReplacePipe,
     BooleanFormatPipe,
     TranslateContextPipe,
     TranslatablePipe,
@@ -137,6 +138,7 @@ export class SharedPipesModule {
             CapitalizePipe,
             StrLengthPipe,
             StrIncludesPipe,
+            StrReplacePipe,
             BooleanFormatPipe,
             TranslateContextPipe,
             TranslatablePipe,
@@ -203,6 +205,7 @@ export class SharedPipesModule {
             CapitalizePipe,
             StrLengthPipe,
             StrIncludesPipe,
+            StrReplacePipe,
             BooleanFormatPipe,
             TranslateContextPipe,
             TranslatablePipe,
@@ -241,4 +244,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     exports: components,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipes.module.js","sourceRoot":"","sources":["../../../../../../src/app/shared/pipes/pipes.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { IonicModule } from '@ionic/angular';\nimport { DateFormatPipe } from './date-format.pipe';\nimport { DateDiffDurationPipe } from './date-diff-duration.pipe';\nimport { DateFromNowPipe } from './date-from-now.pipe';\nimport { LatitudeFormatPipe, LatLongFormatPipe, LongitudeFormatPipe } from './latlong-format.pipe';\nimport { NumberFormatPipe } from './number-format.pipe';\nimport { HighlightPipe } from './highlight.pipe';\nimport { FileSizePipe } from './file-size.pipe';\nimport { DurationPipe } from './duration.pipe';\nimport { EvenPipe, MathAbsPipe, OddPipe } from './math.pipes';\nimport {\n  ArrayFilterPipe,\n  ArrayFirstPipe,\n  ArrayIncludesPipe,\n  ArrayJoinPipe,\n  ArrayLastPipe,\n  ArrayLengthPipe,\n  ArrayPluckPipe,\n  EmptyArrayPipe,\n  NotEmptyArrayPipe,\n} from './arrays.pipe';\nimport { MapGetPipe, MapKeysPipe, MapValuesPipe } from './maps.pipe';\nimport { TranslatablePipe, TranslateContextPipe } from './translate-context.pipe';\nimport { NgInitDirective } from './ng-init.pipe';\nimport {\n  FormErrorPipe,\n  FormErrorTranslatePipe,\n  FormGetArrayPipe,\n  FormGetControlPipe,\n  FormGetGroupPipe,\n  FormGetPipe,\n  FormGetValuePipe,\n} from './form.pipes';\nimport { BooleanFormatPipe, PropertyFormatPipe, PropertyGetPipe, ValueFormatPipe } from './property.pipes';\nimport { MatColorPipe } from './colors.pipe';\nimport { AsAnyPipe, AsArrayPipe, AsBooleanPipe, AsFloatLabelTypePipe, AsObservablePipe } from './types.pipes';\nimport { MaskitoPlaceholderPipe } from './maskito.pipe';\nimport {\n  IsEmptySelectionPipe,\n  IsMultipleSelectionPipe,\n  IsNotEmptySelectionPipe,\n  IsSelectedPipe,\n  IsSingleSelectionPipe,\n  SelectionLengthPipe,\n} from './selection.pipes';\nimport { BadgeNumberPipe } from './badge.pipes';\nimport {\n  CapitalizePipe,\n  IsNilOrBlankPipe,\n  IsNilOrNaNPipe,\n  IsNilPipe,\n  IsNotNilOrBlankPipe,\n  IsNotNilOrNaNPipe,\n  IsNotNilPipe,\n  StrIncludesPipe,\n  StrLengthPipe,\n  ToStringPipe,\n} from './string.pipes';\nimport { NoHtmlPipe, SafeHtmlPipe } from './html.pipes';\nimport { DisplayWithPipe } from './display-with.pipe';\nimport { IsValidDatePipe } from './dates.pipe';\n\nconst components = [\n  PropertyGetPipe,\n  PropertyFormatPipe,\n  ValueFormatPipe,\n  DateFormatPipe,\n  DateDiffDurationPipe,\n  DurationPipe,\n  DateFromNowPipe,\n  LatLongFormatPipe,\n  LatitudeFormatPipe,\n  LongitudeFormatPipe,\n  HighlightPipe,\n  NumberFormatPipe,\n  FileSizePipe,\n  MathAbsPipe,\n  OddPipe,\n  EvenPipe,\n  NotEmptyArrayPipe,\n  EmptyArrayPipe,\n  ArrayLengthPipe,\n  ArrayFirstPipe,\n  ArrayLastPipe,\n  ArrayPluckPipe,\n  ArrayIncludesPipe,\n  ArrayFilterPipe,\n  ArrayJoinPipe,\n  MapGetPipe,\n  MapKeysPipe,\n  MapValuesPipe,\n  IsNilOrBlankPipe,\n  IsNotNilOrBlankPipe,\n  IsNilOrNaNPipe,\n  IsNotNilOrNaNPipe,\n  IsNotNilPipe,\n  IsNilPipe,\n  IsValidDatePipe,\n  ToStringPipe,\n  CapitalizePipe,\n  StrLengthPipe,\n  StrIncludesPipe,\n  BooleanFormatPipe,\n  TranslateContextPipe,\n  TranslatablePipe,\n  NgInitDirective,\n  FormErrorPipe,\n  FormErrorTranslatePipe,\n  FormGetPipe,\n  FormGetControlPipe,\n  FormGetArrayPipe,\n  FormGetGroupPipe,\n  FormGetValuePipe,\n  MatColorPipe,\n  AsAnyPipe,\n  AsArrayPipe,\n  AsObservablePipe,\n  AsFloatLabelTypePipe,\n  MaskitoPlaceholderPipe,\n  IsSelectedPipe,\n  IsNotEmptySelectionPipe,\n  IsEmptySelectionPipe,\n  SelectionLengthPipe,\n  IsMultipleSelectionPipe,\n  IsSingleSelectionPipe,\n  BadgeNumberPipe,\n  AsBooleanPipe,\n  SafeHtmlPipe,\n  NoHtmlPipe,\n  DisplayWithPipe,\n];\n\n@NgModule({\n  imports: [CommonModule, IonicModule, TranslateModule],\n  declarations: components,\n  exports: components,\n})\nexport class SharedPipesModule {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipes.module.js","sourceRoot":"","sources":["../../../../../../src/app/shared/pipes/pipes.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { IonicModule } from '@ionic/angular';\nimport { DateFormatPipe } from './date-format.pipe';\nimport { DateDiffDurationPipe } from './date-diff-duration.pipe';\nimport { DateFromNowPipe } from './date-from-now.pipe';\nimport { LatitudeFormatPipe, LatLongFormatPipe, LongitudeFormatPipe } from './latlong-format.pipe';\nimport { NumberFormatPipe } from './number-format.pipe';\nimport { HighlightPipe } from './highlight.pipe';\nimport { FileSizePipe } from './file-size.pipe';\nimport { DurationPipe } from './duration.pipe';\nimport { EvenPipe, MathAbsPipe, OddPipe } from './math.pipes';\nimport {\n  ArrayFilterPipe,\n  ArrayFirstPipe,\n  ArrayIncludesPipe,\n  ArrayJoinPipe,\n  ArrayLastPipe,\n  ArrayLengthPipe,\n  ArrayPluckPipe,\n  EmptyArrayPipe,\n  NotEmptyArrayPipe,\n} from './arrays.pipe';\nimport { MapGetPipe, MapKeysPipe, MapValuesPipe } from './maps.pipe';\nimport { TranslatablePipe, TranslateContextPipe } from './translate-context.pipe';\nimport { NgInitDirective } from './ng-init.pipe';\nimport {\n  FormErrorPipe,\n  FormErrorTranslatePipe,\n  FormGetArrayPipe,\n  FormGetControlPipe,\n  FormGetGroupPipe,\n  FormGetPipe,\n  FormGetValuePipe,\n} from './form.pipes';\nimport { BooleanFormatPipe, PropertyFormatPipe, PropertyGetPipe, ValueFormatPipe } from './property.pipes';\nimport { MatColorPipe } from './colors.pipe';\nimport { AsAnyPipe, AsArrayPipe, AsBooleanPipe, AsFloatLabelTypePipe, AsObservablePipe } from './types.pipes';\nimport { MaskitoPlaceholderPipe } from './maskito.pipe';\nimport {\n  IsEmptySelectionPipe,\n  IsMultipleSelectionPipe,\n  IsNotEmptySelectionPipe,\n  IsSelectedPipe,\n  IsSingleSelectionPipe,\n  SelectionLengthPipe,\n} from './selection.pipes';\nimport { BadgeNumberPipe } from './badge.pipes';\nimport {\n  CapitalizePipe,\n  IsNilOrBlankPipe,\n  IsNilOrNaNPipe,\n  IsNilPipe,\n  IsNotNilOrBlankPipe,\n  IsNotNilOrNaNPipe,\n  IsNotNilPipe,\n  StrIncludesPipe,\n  StrLengthPipe,\n  StrReplacePipe,\n  ToStringPipe,\n} from './string.pipes';\nimport { NoHtmlPipe, SafeHtmlPipe } from './html.pipes';\nimport { DisplayWithPipe } from './display-with.pipe';\nimport { IsValidDatePipe } from './dates.pipe';\n\nconst components = [\n  PropertyGetPipe,\n  PropertyFormatPipe,\n  ValueFormatPipe,\n  DateFormatPipe,\n  DateDiffDurationPipe,\n  DurationPipe,\n  DateFromNowPipe,\n  LatLongFormatPipe,\n  LatitudeFormatPipe,\n  LongitudeFormatPipe,\n  HighlightPipe,\n  NumberFormatPipe,\n  FileSizePipe,\n  MathAbsPipe,\n  OddPipe,\n  EvenPipe,\n  NotEmptyArrayPipe,\n  EmptyArrayPipe,\n  ArrayLengthPipe,\n  ArrayFirstPipe,\n  ArrayLastPipe,\n  ArrayPluckPipe,\n  ArrayIncludesPipe,\n  ArrayFilterPipe,\n  ArrayJoinPipe,\n  MapGetPipe,\n  MapKeysPipe,\n  MapValuesPipe,\n  IsNilOrBlankPipe,\n  IsNotNilOrBlankPipe,\n  IsNilOrNaNPipe,\n  IsNotNilOrNaNPipe,\n  IsNotNilPipe,\n  IsNilPipe,\n  IsValidDatePipe,\n  ToStringPipe,\n  CapitalizePipe,\n  StrLengthPipe,\n  StrIncludesPipe,\n  StrReplacePipe,\n  BooleanFormatPipe,\n  TranslateContextPipe,\n  TranslatablePipe,\n  NgInitDirective,\n  FormErrorPipe,\n  FormErrorTranslatePipe,\n  FormGetPipe,\n  FormGetControlPipe,\n  FormGetArrayPipe,\n  FormGetGroupPipe,\n  FormGetValuePipe,\n  MatColorPipe,\n  AsAnyPipe,\n  AsArrayPipe,\n  AsObservablePipe,\n  AsFloatLabelTypePipe,\n  MaskitoPlaceholderPipe,\n  IsSelectedPipe,\n  IsNotEmptySelectionPipe,\n  IsEmptySelectionPipe,\n  SelectionLengthPipe,\n  IsMultipleSelectionPipe,\n  IsSingleSelectionPipe,\n  BadgeNumberPipe,\n  AsBooleanPipe,\n  SafeHtmlPipe,\n  NoHtmlPipe,\n  DisplayWithPipe,\n];\n\n@NgModule({\n  imports: [CommonModule, IonicModule, TranslateModule],\n  declarations: components,\n  exports: components,\n})\nexport class SharedPipesModule {}\n"]}