@sumaris-net/ngx-components 18.5.14 → 18.6.1

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

@@ -0,0 +1,88 @@
+// function that returns `MarkedOptions` with renderer override
+import { MarkdownModule, MARKED_OPTIONS } from 'ngx-markdown';
+import { NgModule, SecurityContext } from '@angular/core';
+import { MarkdownService } from './markdown.service';
+import { MarkdownDirective } from './markdown.directive';
+import { HttpClient } from '@angular/common/http';
+import { AppMarkdownModal } from './markdown.modal';
+import { IonicModule } from '@ionic/angular';
+import { TranslateModule } from '@ngx-translate/core';
+import { SharedToolbarModule } from '../toolbar/toolbar.module';
+import { CommonModule } from '@angular/common';
+import { AppMarkdownContent } from './markdown.component';
+import { SharedDebugModule } from '../debug/debug.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "ngx-markdown";
+export class SharedMarkdownModule {
+    static forRoot(opts) {
+        console.debug('[markdown] Creating module (root)');
+        return {
+            ngModule: SharedMarkdownModule,
+            providers: [
+                MarkdownService,
+                MarkdownModule.forRoot({
+                    loader: HttpClient, // Allow to load using [src]
+                    sanitize: SecurityContext.NONE,
+                    ...opts,
+                    markedOptions: opts?.markedOptions || {
+                        provide: MARKED_OPTIONS,
+                        deps: [MarkdownService],
+                        useFactory: (markdownService) => {
+                            console.debug('[markdown] Creating marked options');
+                            return {
+                                renderer: markdownService.renderer,
+                                gfm: true,
+                                breaks: false,
+                                pedantic: false,
+                                smartLists: true,
+                                smartypants: false,
+                            };
+                        },
+                    },
+                }).providers,
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SharedMarkdownModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: SharedMarkdownModule, declarations: [
+            // Component
+            AppMarkdownContent,
+            AppMarkdownModal,
+            // Directive
+            MarkdownDirective], imports: [CommonModule,
+            IonicModule, i1.TranslateModule, i2.MarkdownModule, 
+            // App module
+            SharedToolbarModule,
+            SharedDebugModule], exports: [TranslateModule, MarkdownModule, AppMarkdownContent, MarkdownDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SharedMarkdownModule, imports: [CommonModule,
+            IonicModule,
+            TranslateModule.forChild(),
+            MarkdownModule.forChild(),
+            // App module
+            SharedToolbarModule,
+            SharedDebugModule, TranslateModule, MarkdownModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SharedMarkdownModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        IonicModule,
+                        TranslateModule.forChild(),
+                        MarkdownModule.forChild(),
+                        // App module
+                        SharedToolbarModule,
+                        SharedDebugModule,
+                    ],
+                    declarations: [
+                        // Component
+                        AppMarkdownContent,
+                        AppMarkdownModal,
+                        // Directive
+                        MarkdownDirective,
+                    ],
+                    exports: [TranslateModule, MarkdownModule, AppMarkdownContent, MarkdownDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,203 @@
+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)) {
+            const pageBreak = level < 2;
+            console.debug(`[markdown-service] Heading ${level} '${text}' with anchor ${anchor}`);
+            const link = `<a id="${anchor}" class="anchor ${pageBreak ? 'page-break' : ''}" 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      const pageBreak = level < 2;\n      console.debug(`[markdown-service] Heading ${level} '${text}' with anchor ${anchor}`);\n      const link = `<a id=\"${anchor}\" class=\"anchor ${pageBreak ? 'page-break' : ''}\" 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,46 @@
+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
+    //protected markdownUrl = 'http://localhost:3000/user-manual/index.md';
+    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,
+            canPrint: true,
+        });
+    }
+    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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