@cisstech/nge/esm2022/markdown/src/nge-markdown.service.mjs

NG Essentials is a collection of libraries for Angular developers.

import { Inject, Injectable, Optional } from '@angular/core';
import { marked } from 'marked';
import { NGE_MARKDOWN_CONFIG } from './nge-markdown-config';
import { NgeMarkdownTransformer } from './nge-markdown-transformer';
import { lastValueFrom } from 'rxjs';
import * as i0 from "@angular/core";
import * as i1 from "@cisstech/nge/services";
const WINDOW = window;
/**
 * Markdown compiler service.
 */
export class NgeMarkdownService {
    constructor(config, resourceLoader) {
        this.config = config;
        this.resourceLoader = resourceLoader;
        this.config = config || {};
    }
    /**
     * Compiles a markdown string to an html string.
     * @param options compilation options.
     * @returns A promise that resolve with the AST of the compiled markdown
     * (with the modifications of the contributions).
     */
    async compile(options) {
        let markdown = this.trimIndent(options.markdown);
        if (options.isHtmlString) {
            markdown = this.decodeHtml(markdown);
        }
        const transformer = await this.createTransformer(options);
        const renderer = this.renderer(transformer);
        const tokenizer = this.tokenizer(transformer);
        const markedOptions = {
            gfm: true,
            ...this.config,
            renderer,
            tokenizer,
        };
        markdown = transformer.transformMarkdown(markdown);
        const tokens = transformer.transformAst(marked.lexer(markdown, markedOptions));
        options.target.innerHTML = marked.parser(tokens, markedOptions);
        transformer.transformHTML(options.target);
        return tokens;
    }
    async createTransformer(options) {
        const contributions = [...(options.contributions || [])];
        const transformer = new NgeMarkdownTransformer(this.config);
        const dependencies = [];
        for (const contrib of contributions) {
            if (contrib.dependencies) {
                dependencies.push(...contrib.dependencies());
            }
            contrib.contribute(transformer);
        }
        // Try to fix the issues described here by loading monaco editor
        // after all the other scripts.
        // https://stackoverflow.com/a/33635881
        // https://github.com/microsoft/monaco-editor/issues/662
        // https://github.com/microsoft/monaco-editor/issues/1249
        const define = WINDOW.define;
        WINDOW.define = undefined;
        await lastValueFrom(this.resourceLoader.loadAllSync(dependencies));
        WINDOW.define = define;
        return transformer;
    }
    renderer(transformer) {
        const renderer = transformer.transformRenderer(this.config?.renderer || new marked.Renderer());
        return renderer;
    }
    tokenizer(transformer) {
        return transformer.transformTokenizer(this.config?.tokenizer || new marked.Tokenizer());
    }
    decodeHtml(html) {
        const textarea = document.createElement('textarea');
        textarea.innerHTML = html;
        return textarea.value;
    }
    trimIndent(markdown) {
        if (!markdown) {
            return '';
        }
        let indentStart;
        return markdown
            .split('\n')
            .map((line) => {
            let lineIdentStart = indentStart;
            if (line.length > 0) {
                lineIdentStart = isNaN(lineIdentStart) ? line.search(/\S|$/) : Math.min(line.search(/\S|$/), lineIdentStart);
            }
            if (isNaN(indentStart)) {
                indentStart = lineIdentStart;
            }
            return !!lineIdentStart ? line.substring(lineIdentStart) : line;
        })
            .join('\n');
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: NgeMarkdownService, deps: [{ token: NGE_MARKDOWN_CONFIG, optional: true }, { token: i1.ResourceLoaderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: NgeMarkdownService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: NgeMarkdownService, decorators: [{
            type: Injectable,
            args: [{
                    providedIn: 'root',
                }]
        }], ctorParameters: () => [{ type: undefined, decorators: [{
                    type: Optional
                }, {
                    type: Inject,
                    args: [NGE_MARKDOWN_CONFIG]
                }] }, { type: i1.ResourceLoaderService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nge-markdown.service.js","sourceRoot":"","sources":["../../../../../projects/nge/markdown/src/nge-markdown.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core'\nimport { MarkedOptions, marked } from 'marked'\nimport { NgeMarkdownContribution } from './nge-markdown-contribution'\nimport { NgeMarkdownConfig, NGE_MARKDOWN_CONFIG } from './nge-markdown-config'\nimport { NgeMarkdownTransformer } from './nge-markdown-transformer'\nimport { ResourceLoaderService } from '@cisstech/nge/services'\nimport { lastValueFrom } from 'rxjs'\n\nconst WINDOW = window as any\n\n/**\n * Markdown compiler service.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class NgeMarkdownService {\n  constructor(\n    @Optional()\n    @Inject(NGE_MARKDOWN_CONFIG)\n    readonly config: NgeMarkdownConfig,\n    private readonly resourceLoader: ResourceLoaderService\n  ) {\n    this.config = config || {}\n  }\n\n  /**\n   * Compiles a markdown string to an html string.\n   * @param options compilation options.\n   * @returns A promise that resolve with the AST of the compiled markdown\n   * (with the modifications of the contributions).\n   */\n  async compile(options: NgeMarkdownCompileOptions) {\n    let markdown = this.trimIndent(options.markdown)\n    if (options.isHtmlString) {\n      markdown = this.decodeHtml(markdown)\n    }\n\n    const transformer = await this.createTransformer(options)\n    const renderer = this.renderer(transformer)\n    const tokenizer = this.tokenizer(transformer)\n\n    const markedOptions: MarkedOptions = {\n      gfm: true,\n      ...this.config,\n      renderer,\n      tokenizer,\n    }\n\n    markdown = transformer.transformMarkdown(markdown)\n\n    const tokens = transformer.transformAst(marked.lexer(markdown, markedOptions))\n\n    options.target.innerHTML = marked.parser(tokens, markedOptions)\n\n    transformer.transformHTML(options.target)\n\n    return tokens\n  }\n\n  private async createTransformer(options: NgeMarkdownCompileOptions) {\n    const contributions = [...(options.contributions || [])]\n    const transformer = new NgeMarkdownTransformer(this.config)\n    const dependencies: any[] = []\n    for (const contrib of contributions) {\n      if (contrib.dependencies) {\n        dependencies.push(...contrib.dependencies())\n      }\n      contrib.contribute(transformer)\n    }\n\n    // Try to fix the issues described here by loading monaco editor\n    // after all the other scripts.\n    // https://stackoverflow.com/a/33635881\n    // https://github.com/microsoft/monaco-editor/issues/662\n    // https://github.com/microsoft/monaco-editor/issues/1249\n    const define = WINDOW.define\n    WINDOW.define = undefined\n    await lastValueFrom(this.resourceLoader.loadAllSync(dependencies))\n    WINDOW.define = define\n    return transformer\n  }\n\n  private renderer(transformer: NgeMarkdownTransformer) {\n    const renderer = transformer.transformRenderer(this.config?.renderer || new marked.Renderer())\n    return renderer\n  }\n\n  private tokenizer(transformer: NgeMarkdownTransformer) {\n    return transformer.transformTokenizer(this.config?.tokenizer || new marked.Tokenizer())\n  }\n\n  private decodeHtml(html: string): string {\n    const textarea = document.createElement('textarea')\n    textarea.innerHTML = html\n    return textarea.value\n  }\n\n  private trimIndent(markdown: string): string {\n    if (!markdown) {\n      return ''\n    }\n\n    let indentStart: number\n    return markdown\n      .split('\\n')\n      .map((line) => {\n        let lineIdentStart = indentStart\n        if (line.length > 0) {\n          lineIdentStart = isNaN(lineIdentStart) ? line.search(/\\S|$/) : Math.min(line.search(/\\S|$/), lineIdentStart)\n        }\n        if (isNaN(indentStart)) {\n          indentStart = lineIdentStart\n        }\n        return !!lineIdentStart ? line.substring(lineIdentStart) : line\n      })\n      .join('\\n')\n  }\n}\n\n/**\n * Parameters of NgeMarkdownService `compile` method.\n */\ninterface NgeMarkdownCompileOptions {\n  /** Markdown string to compile. */\n  markdown: string\n  /** HTMLElement on which to render the compiled markdown.  */\n  target: HTMLElement\n  /** Is the markdown contains html code? */\n  isHtmlString?: boolean\n  /** List of contribution to use during the compilation. */\n  contributions?: NgeMarkdownContribution[]\n}\n"]}