@sumaris-net/ngx-components 18.5.14 → 18.6.0

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

@@ -0,0 +1,259 @@
+import { booleanAttribute, ChangeDetectionStrategy, Component, EventEmitter, inject, Input, Optional, Output, } from '@angular/core';
+import { LocalSettingsService } from '../../core/services/local-settings.service';
+import { TranslateService } from '@ngx-translate/core';
+import { NetworkService } from '../../core/services/network.service';
+import { HttpErrorResponse } from '@angular/common/http';
+import { slideDownAnimation } from '../material/material.animations';
+import { MarkdownService } from './markdown.service';
+import { Subscription } from 'rxjs';
+import { UrlUtils } from '../file/url.utils';
+import { isNotEmptyArray, isNotNilOrBlank } from '../functions';
+import { NavController } from '@ionic/angular';
+import { MarkdownUtils } from './markdown.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+import * as i3 from "@ionic/angular";
+import * as i4 from "ngx-markdown";
+import * as i5 from "../debug/debug.component";
+import * as i6 from "./markdown.directive";
+import * as i7 from "@ngx-translate/core";
+export class AppMarkdownContent {
+    cd;
+    element;
+    route;
+    navController = inject(NavController);
+    settings = inject(LocalSettingsService);
+    translate = inject(TranslateService);
+    network = inject(NetworkService);
+    markdownService = inject(MarkdownService);
+    _clickSubscription;
+    loading = true;
+    error = undefined;
+    baseUrl;
+    _data;
+    _src;
+    _fallbackSrc;
+    _anchor;
+    _navHistory = [];
+    set data(value) {
+        this.setData(value);
+    }
+    get data() {
+        return this._data;
+    }
+    set src(value) {
+        this.setSrc(value);
+    }
+    get src() {
+        return this._src;
+    }
+    set anchor(value) {
+        this._anchor = value;
+    }
+    get anchor() {
+        return this._anchor;
+    }
+    debug;
+    showError = true;
+    animated = true;
+    enableNavigationHistory = true;
+    updateRouteLocation = false;
+    markdownUrlChange = new EventEmitter();
+    constructor(cd, element, route // Modal editor give 'null'
+    ) {
+        this.cd = cd;
+        this.element = element;
+        this.route = route;
+        // TODO: for DEV only
+        //this.debug = !environment.production;
+    }
+    ngOnDestroy() {
+        this._clickSubscription?.unsubscribe();
+        this.markdownService.resetBaseUrl();
+    }
+    goBack(event) {
+        console.debug('[markdown] Going back');
+        if (isNotEmptyArray(this._navHistory)) {
+            const { src, fallbackSrc, data, anchor } = this._navHistory.pop();
+            if (src)
+                this.setSrc(src, { fallbackSrc, anchor });
+            else
+                this.setData(data);
+        }
+        else {
+            this.navController.back();
+        }
+    }
+    get canGoBack() {
+        return isNotEmptyArray(this._navHistory);
+    }
+    setData(value, opts) {
+        const anchor = opts?.anchor || null;
+        if (this._data !== value || this._anchor !== anchor) {
+            if (value) {
+                // Save current state to navigation history
+                if (opts?.addToNavigationHistory) {
+                    this._navHistory.push({
+                        src: this._src,
+                        fallbackSrc: this._fallbackSrc,
+                        data: this._data,
+                        anchor: this._anchor,
+                    });
+                }
+                this._data = value;
+                this._anchor = anchor;
+                // Clear src
+                this._src = null;
+                this._fallbackSrc = null;
+                this.resetError();
+                this.markAsLoaded();
+            }
+            else {
+                this._data = null;
+            }
+            this.cd.markForCheck();
+        }
+    }
+    setSrc(src, opts) {
+        // Clean URL (remove fragment and query)
+        const anchor = opts?.anchor || UrlUtils.getFragment(src);
+        src = UrlUtils.stripFragmentAndQuery(src);
+        let fallbackSrc = opts?.fallbackSrc ? UrlUtils.stripFragmentAndQuery(opts.fallbackSrc) : null;
+        if (this._src !== src || this._fallbackSrc !== fallbackSrc || this._anchor !== anchor) {
+            const url = src ? src + (isNotNilOrBlank(anchor) ? `#${anchor}` : '') : null;
+            if (url)
+                console.debug(`[markdown] Loading ${url}...`);
+            // Give baseUrl to the service, to be able to resolve relative path - e.g. images)
+            if (src && UrlUtils.isExternalUrl(src)) {
+                this.baseUrl = UrlUtils.getParent(src);
+                this.markdownService.setBaseUrl(this.baseUrl);
+            }
+            if (src) {
+                // Save current state to navigation history
+                if (opts?.addToNavigationHistory) {
+                    this._navHistory.push({
+                        src: this._src,
+                        fallbackSrc: this._fallbackSrc,
+                        data: this._data,
+                        anchor: this._anchor,
+                    });
+                }
+                this._src = src;
+                this._fallbackSrc = fallbackSrc;
+                this._anchor = anchor;
+                // Clear data
+                this._data = null;
+                // Reset error
+                this.resetError();
+                this.markAsLoading();
+            }
+            else {
+                this._src = null;
+                this._fallbackSrc = null;
+                this._anchor = null;
+                this.cd.markForCheck();
+            }
+        }
+    }
+    onReady() {
+        const url = this._src ? this._src + (isNotNilOrBlank(this._anchor) ? `#${this._anchor}` : '') : null;
+        if (url) {
+            console.debug(`[markdown] Ready - ${url}`);
+            // Clear fallback (no more need)
+            if (this._fallbackSrc)
+                this._fallbackSrc = null;
+            // Emit change
+            this.markdownUrlChange.emit(url);
+        }
+        this.startListenClickEvents();
+        this.markAsLoaded();
+        // Scroll to anchor
+        if (isNotNilOrBlank(this._anchor)) {
+            this.markdownService.scrollToAnchor(this.element.nativeElement, this._anchor);
+        }
+    }
+    onLoadError(error) {
+        // Translate error
+        if (error instanceof HttpErrorResponse && this.network.offline) {
+            console.error(`[markdown] Error loading markdown URL {${this.src}} (offline: true): `, error);
+            this.error = 'NETWORK.INFO.OFFLINE';
+        }
+        else {
+            // Retry with fallback URL
+            if (this._fallbackSrc) {
+                console.debug(`[markdown] Error loading markdown URL {${this.src}} - fallback to URL ${this._fallbackSrc}`);
+                this.setSrc(this._fallbackSrc, { anchor: this._anchor });
+                return;
+            }
+            console.error(`[markdown] Error loading markdown URL {${this.src}} (offline: true): `, error);
+            this.error = 'ERROR.LOAD_DATA_ERROR';
+        }
+        this.markAsLoaded();
+    }
+    startListenClickEvents() {
+        this._clickSubscription?.unsubscribe();
+        this._clickSubscription = new Subscription();
+        // Listen for click link to Markdown URL
+        this._clickSubscription.add(this.markdownService.onClickMarkdownUrl.subscribe((href) => {
+            console.debug('[markdown] Received click event, on a markdown URL', href);
+            let fragment = UrlUtils.getFragment(href);
+            let url = UrlUtils.stripFragmentAndQuery(href);
+            let fallbackUrl = null;
+            // Resolve relative path
+            if (UrlUtils.isRelativeUrl(href) && this.baseUrl) {
+                // Get absolute url
+                url = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href);
+                // Create a fallback url, in relative path was wrong
+                fallbackUrl = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href, { absoluteByDefault: true });
+                fallbackUrl = url === fallbackUrl ? null : fallbackUrl;
+            }
+            // Opening the new URL
+            this.setSrc(url, { fallbackSrc: fallbackUrl, anchor: fragment, addToNavigationHistory: this.enableNavigationHistory });
+        }));
+    }
+    markAsLoaded() {
+        this.loading = false;
+        this.cd.markForCheck();
+    }
+    markAsLoading() {
+        this.loading = true;
+        this.cd.markForCheck();
+    }
+    resetError() {
+        this.error = null;
+        this.cd.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppMarkdownContent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.ActivatedRoute, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: AppMarkdownContent, selector: "app-markdown-content", inputs: { data: "data", src: "src", anchor: "anchor", debug: ["debug", "debug", booleanAttribute], showError: ["showError", "showError", booleanAttribute], animated: ["animated", "animated", booleanAttribute], enableNavigationHistory: ["enableNavigationHistory", "enableNavigationHistory", booleanAttribute], updateRouteLocation: ["updateRouteLocation", "updateRouteLocation", booleanAttribute] }, outputs: { markdownUrlChange: "markdownUrlChange" }, ngImport: i0, template: "<app-debug *ngIf=\"debug\">\n  <ion-grid class=\"ion-no-padding\">\n    <ion-row>\n      <ion-col>\n        loading: {{ loading }}\n        <br />\n        error: {{ error }}\n        <br />\n        <br />\n        baseUrl: {{ baseUrl }}\n        <br />\n        markdownUrl: {{ src }}\n        <br />\n        markdownFragment: {{ _anchor }}\n        <br />\n        markdownContent: {{ data }}\n        <br />\n      </ion-col>\n    </ion-row>\n  </ion-grid>\n</app-debug>\n\n<!-- error -->\n@if (showError && error; as error) {\n  <ion-item lines=\"none\" @slideDownAnimation>\n    <ion-icon color=\"danger\" slot=\"start\" name=\"alert-circle\"></ion-icon>\n    <ion-label color=\"danger\" class=\"error\" [innerHTML]=\"error | translate\"></ion-label>\n  </ion-item>\n} @else {\n  @if (data) {\n    <markdown [data]=\"data\" (ready)=\"onReady()\" emoji></markdown>\n  } @else if (src) {\n    <markdown [src]=\"src\" (error)=\"onLoadError($event)\" (ready)=\"onReady()\" emoji></markdown>\n  }\n}\n\n<!-- loading spinner -->\n@if (loading) {\n  <div class=\"loading-spinner\">\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n  </div>\n}\n\n<ng-template #loadingParagraph>\n  <p>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 75%; margin-inline-start: 5%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n  </p>\n</ng-template>\n", styles: [":host ::ng-deep markdown div.logo{display:none;visibility:hidden}:host ::ng-deep markdown blockquote{--block-margin: 16px 0;--block-padding: 4px 16px;--box-shadow: 0 2px 4px rgba(0, 0, 0, .4);display:block;position:relative;width:70%;margin:var(--block-margin);padding:var(--block-padding);font-style:italic;background:var(--ion-color-light);box-shadow:var(--box-shadow)}:host ::ng-deep markdown code{color:rgba(var(--ion-text-color-rgb),.7);background:rgba(var(--ion-text-color-rgb),.03);font-size:.9rem;letter-spacing:-.5px}.loading-spinner ion-skeleton-text{width:100%;height:1.5em}.loading-spinner p{margin-top:var(ion-padding, 16px)}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i3.IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { kind: "component", type: i3.IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { kind: "component", type: i3.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i3.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "counterFormatter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { kind: "component", type: i3.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: i3.IonRow, selector: "ion-row" }, { kind: "component", type: i3.IonSkeletonText, selector: "ion-skeleton-text", inputs: ["animated"] }, { kind: "component", type: i4.MarkdownComponent, selector: "markdown, [markdown]", inputs: ["data", "src", "disableSanitizer", "inline", "clipboard", "clipboardButtonComponent", "clipboardButtonTemplate", "emoji", "katex", "katexOptions", "mermaid", "mermaidOptions", "lineHighlight", "line", "lineOffset", "lineNumbers", "start", "commandLine", "filterOutput", "host", "prompt", "output", "user"], outputs: ["error", "load", "ready"] }, { kind: "component", type: i5.DebugComponent, selector: "app-debug", inputs: ["titlePrefix", "title", "enable", "expanded"] }, { kind: "directive", type: i6.MarkdownDirective, selector: "markdown,[markdown]" }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }], animations: [slideDownAnimation], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppMarkdownContent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-markdown-content', changeDetection: ChangeDetectionStrategy.OnPush, animations: [slideDownAnimation], template: "<app-debug *ngIf=\"debug\">\n  <ion-grid class=\"ion-no-padding\">\n    <ion-row>\n      <ion-col>\n        loading: {{ loading }}\n        <br />\n        error: {{ error }}\n        <br />\n        <br />\n        baseUrl: {{ baseUrl }}\n        <br />\n        markdownUrl: {{ src }}\n        <br />\n        markdownFragment: {{ _anchor }}\n        <br />\n        markdownContent: {{ data }}\n        <br />\n      </ion-col>\n    </ion-row>\n  </ion-grid>\n</app-debug>\n\n<!-- error -->\n@if (showError && error; as error) {\n  <ion-item lines=\"none\" @slideDownAnimation>\n    <ion-icon color=\"danger\" slot=\"start\" name=\"alert-circle\"></ion-icon>\n    <ion-label color=\"danger\" class=\"error\" [innerHTML]=\"error | translate\"></ion-label>\n  </ion-item>\n} @else {\n  @if (data) {\n    <markdown [data]=\"data\" (ready)=\"onReady()\" emoji></markdown>\n  } @else if (src) {\n    <markdown [src]=\"src\" (error)=\"onLoadError($event)\" (ready)=\"onReady()\" emoji></markdown>\n  }\n}\n\n<!-- loading spinner -->\n@if (loading) {\n  <div class=\"loading-spinner\">\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n  </div>\n}\n\n<ng-template #loadingParagraph>\n  <p>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 75%; margin-inline-start: 5%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n  </p>\n</ng-template>\n", styles: [":host ::ng-deep markdown div.logo{display:none;visibility:hidden}:host ::ng-deep markdown blockquote{--block-margin: 16px 0;--block-padding: 4px 16px;--box-shadow: 0 2px 4px rgba(0, 0, 0, .4);display:block;position:relative;width:70%;margin:var(--block-margin);padding:var(--block-padding);font-style:italic;background:var(--ion-color-light);box-shadow:var(--box-shadow)}:host ::ng-deep markdown code{color:rgba(var(--ion-text-color-rgb),.7);background:rgba(var(--ion-text-color-rgb),.03);font-size:.9rem;letter-spacing:-.5px}.loading-spinner ion-skeleton-text{width:100%;height:1.5em}.loading-spinner p{margin-top:var(ion-padding, 16px)}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i1.ActivatedRoute, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { data: [{
+                type: Input
+            }], src: [{
+                type: Input
+            }], anchor: [{
+                type: Input
+            }], debug: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], showError: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], animated: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], enableNavigationHistory: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], updateRouteLocation: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], markdownUrlChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown.component.js","sourceRoot":"","sources":["../../../../../../src/app/shared/markdown/markdown.component.ts","../../../../../../src/app/shared/markdown/markdown.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  booleanAttribute,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  inject,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n} from '@angular/core';\nimport { LocalSettingsService } from '../../core/services/local-settings.service';\nimport { TranslateService } from '@ngx-translate/core';\nimport { NetworkService } from '../../core/services/network.service';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { slideDownAnimation } from '../material/material.animations';\nimport { MarkdownService } from './markdown.service';\nimport { Subscription } from 'rxjs';\nimport { UrlUtils } from '../file/url.utils';\nimport { isNotEmptyArray, isNotNilOrBlank } from '../functions';\nimport { NavController } from '@ionic/angular';\nimport { MarkdownUtils } from './markdown.utils';\nimport { ActivatedRoute } from '@angular/router';\n\nexport interface AppMarkdownOptions {\n  data?: string;\n  src?: string;\n  showError?: boolean;\n}\n\n@Component({\n  selector: 'app-markdown-content',\n  templateUrl: './markdown.component.html',\n  styleUrls: ['./markdown.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  animations: [slideDownAnimation],\n})\nexport class AppMarkdownContent implements AppMarkdownOptions, OnDestroy {\n  protected navController = inject(NavController);\n  protected settings = inject(LocalSettingsService);\n  protected translate = inject(TranslateService);\n  protected network = inject(NetworkService);\n  protected markdownService = inject(MarkdownService);\n\n  protected _clickSubscription: Subscription;\n  protected loading = true;\n  protected error: string = undefined;\n\n  protected baseUrl: string;\n\n  protected _data: string;\n  protected _src: string;\n  protected _fallbackSrc: string;\n  protected _anchor: string;\n\n  protected _navHistory: { src?: string; fallbackSrc?: string; data?: string; anchor?: string }[] = [];\n\n  @Input() set data(value: string) {\n    this.setData(value);\n  }\n  get data() {\n    return this._data;\n  }\n\n  @Input() set src(value: string) {\n    this.setSrc(value);\n  }\n  get src() {\n    return this._src;\n  }\n\n  @Input() set anchor(value: string) {\n    this._anchor = value;\n  }\n  get anchor() {\n    return this._anchor;\n  }\n\n  @Input({ transform: booleanAttribute }) debug: boolean;\n  @Input({ transform: booleanAttribute }) showError = true;\n  @Input({ transform: booleanAttribute }) animated = true;\n  @Input({ transform: booleanAttribute }) enableNavigationHistory = true;\n  @Input({ transform: booleanAttribute }) updateRouteLocation = false;\n\n  @Output() markdownUrlChange = new EventEmitter<string>();\n\n  constructor(\n    protected cd: ChangeDetectorRef,\n    protected element: ElementRef<HTMLElement>,\n    @Optional() protected route: ActivatedRoute // Modal editor give 'null'\n  ) {\n    // TODO: for DEV only\n    //this.debug = !environment.production;\n  }\n\n  ngOnDestroy() {\n    this._clickSubscription?.unsubscribe();\n    this.markdownService.resetBaseUrl();\n  }\n\n  goBack(event?: Event) {\n    console.debug('[markdown] Going back');\n    if (isNotEmptyArray(this._navHistory)) {\n      const { src, fallbackSrc, data, anchor } = this._navHistory.pop();\n      if (src) this.setSrc(src, { fallbackSrc, anchor });\n      else this.setData(data);\n    } else {\n      this.navController.back();\n    }\n  }\n\n  get canGoBack() {\n    return isNotEmptyArray(this._navHistory);\n  }\n\n  protected setData(value: string, opts?: { anchor?: string; addToNavigationHistory?: boolean }) {\n    const anchor = opts?.anchor || null;\n\n    if (this._data !== value || this._anchor !== anchor) {\n      if (value) {\n        // Save current state to navigation history\n        if (opts?.addToNavigationHistory) {\n          this._navHistory.push({\n            src: this._src,\n            fallbackSrc: this._fallbackSrc,\n            data: this._data,\n            anchor: this._anchor,\n          });\n        }\n\n        this._data = value;\n        this._anchor = anchor;\n\n        // Clear src\n        this._src = null;\n        this._fallbackSrc = null;\n\n        this.resetError();\n        this.markAsLoaded();\n      } else {\n        this._data = null;\n      }\n      this.cd.markForCheck();\n    }\n  }\n\n  protected setSrc(src: string, opts?: { fallbackSrc?: string; anchor?: string; addToNavigationHistory?: boolean }) {\n    // Clean URL (remove fragment and query)\n    const anchor = opts?.anchor || UrlUtils.getFragment(src);\n    src = UrlUtils.stripFragmentAndQuery(src);\n    let fallbackSrc = opts?.fallbackSrc ? UrlUtils.stripFragmentAndQuery(opts.fallbackSrc) : null;\n\n    if (this._src !== src || this._fallbackSrc !== fallbackSrc || this._anchor !== anchor) {\n      const url = src ? src + (isNotNilOrBlank(anchor) ? `#${anchor}` : '') : null;\n      if (url) console.debug(`[markdown] Loading ${url}...`);\n\n      // Give baseUrl to the service, to be able to resolve relative path - e.g. images)\n      if (src && UrlUtils.isExternalUrl(src)) {\n        this.baseUrl = UrlUtils.getParent(src);\n        this.markdownService.setBaseUrl(this.baseUrl);\n      }\n\n      if (src) {\n        // Save current state to navigation history\n        if (opts?.addToNavigationHistory) {\n          this._navHistory.push({\n            src: this._src,\n            fallbackSrc: this._fallbackSrc,\n            data: this._data,\n            anchor: this._anchor,\n          });\n        }\n\n        this._src = src;\n        this._fallbackSrc = fallbackSrc;\n        this._anchor = anchor;\n\n        // Clear data\n        this._data = null;\n\n        // Reset error\n        this.resetError();\n        this.markAsLoading();\n      } else {\n        this._src = null;\n        this._fallbackSrc = null;\n        this._anchor = null;\n        this.cd.markForCheck();\n      }\n    }\n  }\n\n  protected onReady() {\n    const url = this._src ? this._src + (isNotNilOrBlank(this._anchor) ? `#${this._anchor}` : '') : null;\n\n    if (url) {\n      console.debug(`[markdown] Ready - ${url}`);\n      // Clear fallback (no more need)\n      if (this._fallbackSrc) this._fallbackSrc = null;\n\n      // Emit change\n      this.markdownUrlChange.emit(url);\n    }\n\n    this.startListenClickEvents();\n\n    this.markAsLoaded();\n\n    // Scroll to anchor\n    if (isNotNilOrBlank(this._anchor)) {\n      this.markdownService.scrollToAnchor(this.element.nativeElement, this._anchor);\n    }\n  }\n\n  protected onLoadError(error?: string | Error) {\n    // Translate error\n    if (error instanceof HttpErrorResponse && this.network.offline) {\n      console.error(`[markdown] Error loading markdown URL {${this.src}} (offline: true): `, error);\n      this.error = 'NETWORK.INFO.OFFLINE';\n    } else {\n      // Retry with fallback URL\n      if (this._fallbackSrc) {\n        console.debug(`[markdown] Error loading markdown URL {${this.src}} - fallback to URL ${this._fallbackSrc}`);\n        this.setSrc(this._fallbackSrc, { anchor: this._anchor });\n        return;\n      }\n\n      console.error(`[markdown] Error loading markdown URL {${this.src}} (offline: true): `, error);\n      this.error = 'ERROR.LOAD_DATA_ERROR';\n    }\n\n    this.markAsLoaded();\n  }\n\n  protected startListenClickEvents() {\n    this._clickSubscription?.unsubscribe();\n    this._clickSubscription = new Subscription();\n\n    // Listen for click link to Markdown URL\n    this._clickSubscription.add(\n      this.markdownService.onClickMarkdownUrl.subscribe((href) => {\n        console.debug('[markdown] Received click event, on a markdown URL', href);\n\n        let fragment = UrlUtils.getFragment(href);\n        let url = UrlUtils.stripFragmentAndQuery(href);\n        let fallbackUrl = null;\n\n        // Resolve relative path\n        if (UrlUtils.isRelativeUrl(href) && this.baseUrl) {\n          // Get absolute url\n          url = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href);\n\n          // Create a fallback url, in relative path was wrong\n          fallbackUrl = MarkdownUtils.resolveRelativeUrl(this.baseUrl, href, { absoluteByDefault: true });\n          fallbackUrl = url === fallbackUrl ? null : fallbackUrl;\n        }\n\n        // Opening the new URL\n        this.setSrc(url, { fallbackSrc: fallbackUrl, anchor: fragment, addToNavigationHistory: this.enableNavigationHistory });\n      })\n    );\n  }\n\n  protected markAsLoaded() {\n    this.loading = false;\n    this.cd.markForCheck();\n  }\n\n  protected markAsLoading() {\n    this.loading = true;\n    this.cd.markForCheck();\n  }\n\n  protected resetError() {\n    this.error = null;\n    this.cd.markForCheck();\n  }\n}\n","<app-debug *ngIf=\"debug\">\n  <ion-grid class=\"ion-no-padding\">\n    <ion-row>\n      <ion-col>\n        loading: {{ loading }}\n        <br />\n        error: {{ error }}\n        <br />\n        <br />\n        baseUrl: {{ baseUrl }}\n        <br />\n        markdownUrl: {{ src }}\n        <br />\n        markdownFragment: {{ _anchor }}\n        <br />\n        markdownContent: {{ data }}\n        <br />\n      </ion-col>\n    </ion-row>\n  </ion-grid>\n</app-debug>\n\n<!-- error -->\n@if (showError && error; as error) {\n  <ion-item lines=\"none\" @slideDownAnimation>\n    <ion-icon color=\"danger\" slot=\"start\" name=\"alert-circle\"></ion-icon>\n    <ion-label color=\"danger\" class=\"error\" [innerHTML]=\"error | translate\"></ion-label>\n  </ion-item>\n} @else {\n  @if (data) {\n    <markdown [data]=\"data\" (ready)=\"onReady()\" emoji></markdown>\n  } @else if (src) {\n    <markdown [src]=\"src\" (error)=\"onLoadError($event)\" (ready)=\"onReady()\" emoji></markdown>\n  }\n}\n\n<!-- loading spinner -->\n@if (loading) {\n  <div class=\"loading-spinner\">\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"loadingParagraph\"></ng-container>\n  </div>\n}\n\n<ng-template #loadingParagraph>\n  <p>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 75%; margin-inline-start: 5%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n    <ion-skeleton-text [animated]=\"animated\" style=\"width: 80%\"></ion-skeleton-text>\n  </p>\n</ng-template>\n"]}

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

@@ -0,0 +1,34 @@
+import { Directive, HostListener } from '@angular/core';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./markdown.service";
+export class MarkdownDirective {
+    service;
+    element;
+    _subscription = new Subscription();
+    constructor(service, element) {
+        this.service = service;
+        this.element = element;
+        // DEBUG
+        //console.debug('[markdown] Creating markdown directive');
+    }
+    processAnchors() {
+        // Listening click events
+        this._subscription.add(this.service.listenClickEvents(this.element.nativeElement));
+    }
+    ngOnDestroy() {
+        this._subscription.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownDirective, deps: [{ token: i1.MarkdownService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: MarkdownDirective, selector: "markdown,[markdown]", host: { listeners: { "ready": "processAnchors()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MarkdownDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'markdown,[markdown]',
+                }]
+        }], ctorParameters: () => [{ type: i1.MarkdownService }, { type: i0.ElementRef }], propDecorators: { processAnchors: [{
+                type: HostListener,
+                args: ['ready']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,75 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "../../core/services/platform.service";
+import * as i3 from "../../core/services/local-settings.service";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../../core/services/network.service";
+import * as i6 from "../toolbar/modal-toolbar";
+import * as i7 from "./markdown.component";
+export class AppMarkdownModal {
+    injector;
+    viewCtrl;
+    platform;
+    settings;
+    translate;
+    network;
+    cd;
+    loading = true;
+    error = undefined;
+    debug;
+    title;
+    showError = true;
+    markdownContent;
+    markdownUrl;
+    static async show(modalCtrl, options) {
+        const modal = await modalCtrl.create({
+            component: AppMarkdownModal,
+            componentProps: options,
+            keyboardClose: true,
+            cssClass: options?.cssClass || 'modal-large',
+        });
+        await modal.present();
+        return modal.onWillDismiss();
+    }
+    constructor(injector, viewCtrl, platform, settings, translate, network, cd) {
+        this.injector = injector;
+        this.viewCtrl = viewCtrl;
+        this.platform = platform;
+        this.settings = settings;
+        this.translate = translate;
+        this.network = network;
+        this.cd = cd;
+        // TODO: for DEV only
+        //this.debug = !environment.production;
+    }
+    close(_) {
+        return this.viewCtrl.dismiss();
+    }
+    goBack(event, content) {
+        if (content?.canGoBack) {
+            content.goBack(event);
+            this.cd.markForCheck();
+        }
+        else {
+            this.close(event);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppMarkdownModal, deps: [{ token: i0.Injector }, { token: i1.ModalController }, { token: i2.PlatformService }, { token: i3.LocalSettingsService }, { token: i4.TranslateService }, { token: i5.NetworkService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: AppMarkdownModal, selector: "app-markdown-modal", inputs: { debug: "debug", title: "title", showError: "showError", markdownContent: "markdownContent", markdownUrl: "markdownUrl" }, ngImport: i0, template: "@if (title) {\n  <app-modal-toolbar color=\"light\" [title]=\"title | translate\" (cancel)=\"close($event)\">\n    @if (content.canGoBack) {\n      <ion-button slot=\"start\" class=\"back-button\" (click)=\"goBack($event, content)\" routerDirection=\"back\">\n        <ion-icon slot=\"icon-only\" name=\"arrow-back\"></ion-icon>\n      </ion-button>\n    }\n  </app-modal-toolbar>\n}\n\n<ion-content class=\"ion-padding\">\n  <app-markdown-content\n    #content\n    [src]=\"markdownUrl\"\n    [data]=\"markdownContent\"\n    [showError]=\"showError\"\n    [debug]=\"debug\"\n    [updateRouteLocation]=\"false\"\n  ></app-markdown-content>\n</ion-content>\n\n<ion-footer hidden-xs hidden-sm hidden-mobile>\n  <ion-toolbar>\n    <ion-row class=\"ion-no-padding\">\n      <ion-col></ion-col>\n      <ion-col size=\"auto\">\n        <ion-button fill=\"solid\" color=\"tertiary\" (click)=\"close()\">{{ 'COMMON.BTN_CLOSE' | translate }}</ion-button>\n      </ion-col>\n    </ion-row>\n  </ion-toolbar>\n</ion-footer>\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.IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { kind: "component", type: i1.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i1.IonFooter, selector: "ion-footer", 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.IonRow, selector: "ion-row" }, { kind: "component", type: i1.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: i6.ModalToolbarComponent, selector: "app-modal-toolbar", inputs: ["modalName", "title", "color", "showSpinner", "canValidate", "validateIcon"], outputs: ["cancel", "validate"] }, { kind: "component", type: i7.AppMarkdownContent, selector: "app-markdown-content", inputs: ["data", "src", "anchor", "debug", "showError", "animated", "enableNavigationHistory", "updateRouteLocation"], outputs: ["markdownUrlChange"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppMarkdownModal, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-markdown-modal', changeDetection: ChangeDetectionStrategy.OnPush, template: "@if (title) {\n  <app-modal-toolbar color=\"light\" [title]=\"title | translate\" (cancel)=\"close($event)\">\n    @if (content.canGoBack) {\n      <ion-button slot=\"start\" class=\"back-button\" (click)=\"goBack($event, content)\" routerDirection=\"back\">\n        <ion-icon slot=\"icon-only\" name=\"arrow-back\"></ion-icon>\n      </ion-button>\n    }\n  </app-modal-toolbar>\n}\n\n<ion-content class=\"ion-padding\">\n  <app-markdown-content\n    #content\n    [src]=\"markdownUrl\"\n    [data]=\"markdownContent\"\n    [showError]=\"showError\"\n    [debug]=\"debug\"\n    [updateRouteLocation]=\"false\"\n  ></app-markdown-content>\n</ion-content>\n\n<ion-footer hidden-xs hidden-sm hidden-mobile>\n  <ion-toolbar>\n    <ion-row class=\"ion-no-padding\">\n      <ion-col></ion-col>\n      <ion-col size=\"auto\">\n        <ion-button fill=\"solid\" color=\"tertiary\" (click)=\"close()\">{{ 'COMMON.BTN_CLOSE' | translate }}</ion-button>\n      </ion-col>\n    </ion-row>\n  </ion-toolbar>\n</ion-footer>\n" }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.ModalController }, { type: i2.PlatformService }, { type: i3.LocalSettingsService }, { type: i4.TranslateService }, { type: i5.NetworkService }, { type: i0.ChangeDetectorRef }], propDecorators: { debug: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], showError: [{
+                type: Input
+            }], markdownContent: [{
+                type: Input
+            }], markdownUrl: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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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