@covalent/markdown 0.0.1

package/README.md

@@ -0,0 +1,94 @@
+## TdMarkdownComponent: td-markdown
+
+`<td-markdown>` is a component that parses and renders Github flavored markdown. It is based on the [showdown](https://github.com/showdownjs/showdown/) library.
+
+**Note:** This module uses the **DomSanitizer** service to sanitize the parsed html from the showdown lib to avoid **XSS** issues.
+
+By default, `--dev` build will log the following message in the console to let you know:
+
+`WARNING: sanitizing HTML stripped some content (see http://g.co/ng/security#xss).`
+
+## API Summary
+
+#### Inputs
+
+- content?: string
+
+  - Markdown format content to be parsed as html markup.
+  - Used to load data dynamically. e.g. `README.md` content.
+
+- simpleLineBreaks?: string
+
+  - Sets whether newline characters inside paragraphs and spans are parsed as <br/>.
+  - Defaults to false.
+
+- hostedUrl?: string
+
+  - If markdown contains relative paths, this is required to generate correct urls.
+
+- anchor?: string
+  - Anchor to jump to.
+
+#### Events
+
+- contentReady: undefined
+  - Event emitted after the markdown content rendering is finished.
+
+## Installation
+
+This component can be installed as an npm package.
+
+```bash
+npm i -save @covalent/markdown
+```
+
+## Setup
+
+Then, import the **CovalentMarkdownModule** in your NgModule:
+
+```typescript
+import { CovalentMarkdownModule } from '@covalent/markdown';
+@NgModule({
+  imports: [
+    CovalentMarkdownModule,
+    ...
+  ],
+  ...
+})
+export class MyModule {}
+```
+
+### Theming
+
+This module comes with its own Covalent theme which uses the material theme which is used by importing our theme scss file.
+
+```scss
+@import '~@angular/material/theming';
+@import '~@covalent/markdown/markdown-theme';
+
+@include mat-core();
+
+$primary: mat-palette($mat-orange, 800);
+$accent: mat-palette($mat-light-blue, 600, A100, A400);
+$warn: mat-palette($mat-red, 600);
+
+$theme: mat-light-theme($primary, $accent, $warn);
+
+@include covalent-markdown-theme($theme);
+```
+
+## Example
+
+**Html:**
+
+```html
+<td-markdown> # Heading ## Sub Heading (H2) ### Steps (H2) </td-markdown>
+```
+
+**Output:**
+
+# Heading
+
+## Sub Heading (H2)
+
+### Steps (H2)

package/covalent-markdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@covalent/markdown" />
+export * from './public_api';

package/esm2020/covalent-markdown.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQtbWFya2Rvd24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL21hcmtkb3duL3NyYy9jb3ZhbGVudC1tYXJrZG93bi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/esm2020/lib/markdown-loader/markdown-loader.service.mjs

@@ -0,0 +1,41 @@
+import { Injectable, SecurityContext } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { HttpClient } from '@angular/common/http';
+import { isGithubHref, rawGithubHref } from '../markdown-utils/markdown-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/platform-browser";
+export class TdMarkdownLoaderService {
+    constructor(_http, _sanitizer) {
+        this._http = _http;
+        this._sanitizer = _sanitizer;
+    }
+    async load(url, httpOptions = {}) {
+        const sanitizedUrl = this._sanitizer.sanitize(SecurityContext.URL, url) ?? '';
+        let urlToGet = sanitizedUrl;
+        if (isGithubHref(sanitizedUrl)) {
+            urlToGet = rawGithubHref(sanitizedUrl);
+        }
+        const response = await this._http
+            .get(urlToGet, {
+            ...httpOptions,
+            responseType: 'text',
+            observe: 'response',
+        })
+            .toPromise();
+        const contentType = response?.headers.get('Content-Type') ?? '';
+        if (contentType.includes('text/plain') ||
+            contentType.includes('text/markdown')) {
+            return response?.body ?? '';
+        }
+        else {
+            throw Error(`${contentType} is not a handled content type`);
+        }
+    }
+}
+TdMarkdownLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TdMarkdownLoaderService, deps: [{ token: i1.HttpClient }, { token: i2.DomSanitizer }], target: i0.ɵɵFactoryTarget.Injectable });
+TdMarkdownLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TdMarkdownLoaderService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TdMarkdownLoaderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/markdown-utils/markdown-utils.mjs

@@ -0,0 +1,115 @@
+export function removeLeadingHash(str) {
+    if (str) {
+        return str.replace(/^#+/, '');
+    }
+    return '';
+}
+export function removeTrailingHash(str) {
+    if (str) {
+        return str.replace(/#.*/, '');
+    }
+    return '';
+}
+export function genHeadingId(str) {
+    if (str) {
+        return removeLeadingHash(str
+            .replace(/(_|-|\s)+/g, '')
+            // Remove certain special chars to create heading ids similar to those in github
+            // borrowed from showdown
+            // https://github.com/showdownjs/showdown/blob/develop/src/subParsers/makehtml/headers.js#L94
+            .replace(/[&+$,/:;=?@"#{}|^¨~[\]`\\*)(%.!'<>]/g, '')).toLowerCase();
+    }
+    return '';
+}
+export function scrollToAnchor(scope, anchor, tryParent) {
+    if (scope && anchor) {
+        const normalizedAnchor = genHeadingId(anchor);
+        let headingToJumpTo = null;
+        const headingWithinComponent = scope.querySelector(`[id="${normalizedAnchor}"]`);
+        if (headingWithinComponent) {
+            headingToJumpTo = headingWithinComponent;
+        }
+        else if (tryParent) {
+            const parent = scope.parentElement;
+            if (parent) {
+                headingToJumpTo = parent.querySelector(`[id="${normalizedAnchor}"]`);
+            }
+        }
+        if (headingToJumpTo) {
+            headingToJumpTo.scrollIntoView({ behavior: 'auto' });
+            return true;
+        }
+    }
+    return false;
+}
+export function isAnchorLink(anchor) {
+    if (anchor) {
+        const href = anchor.getAttribute('href');
+        if (href) {
+            return href.startsWith('#');
+        }
+    }
+    return false;
+}
+const RAW_GITHUB_HOSTNAME = 'raw.githubusercontent.com';
+export function rawGithubHref(githubHref) {
+    if (githubHref) {
+        try {
+            const url = new URL(githubHref);
+            if (url.hostname === RAW_GITHUB_HOSTNAME) {
+                return url.href;
+            }
+            else if (isGithubHref(githubHref)) {
+                url.hostname = RAW_GITHUB_HOSTNAME;
+                url.pathname = url.pathname.split('/blob', 2).join('');
+                return url.href;
+            }
+        }
+        catch {
+            return '';
+        }
+    }
+    return '';
+}
+export function isGithubHref(href) {
+    try {
+        const temp = new URL(href ?? '');
+        return temp.hostname === 'github.com';
+    }
+    catch {
+        return false;
+    }
+}
+export function isRawGithubHref(href = '') {
+    try {
+        const temp = new URL(href);
+        return temp.hostname === RAW_GITHUB_HOSTNAME;
+    }
+    catch {
+        return false;
+    }
+}
+export function renderVideoElements(html) {
+    const ytLongEmbed = /!\[(?:(?:https?:)?(?:\/\/)?)(?:(?:www)?.)?youtube.(?:.+?)\/(?:(?:embed\/)([\w-]{11})(\?[\w%;-]+(?:=[\w%;-]+)?(?:&[\w%;-]+(?:=[\w%;-]+)?)*)?)]/gi;
+    const ytLongWatch = /!\[(?:(?:https?:)?(?:\/\/)?)(?:(?:www)?.)?youtube.(?:.+?)\/(?:(?:watch\?v=)([\w-]{11})(&[\w%;-]+(?:=[\w%;-]+)?)*)]/gi;
+    const ytShort = /!\[(?:(?:https?:)?(?:\/\/)?)?youtu.be\/([\w-]{11})\??([\w%;-]+(?:=[\w%;-]+)?(?:&[\w%;-]+(?:=[\w%;-]+)?)*)?]/gi;
+    const ytPlaylist = /!\[(?:(?:https?:)?(?:\/\/)?)(?:(?:www)?.)?youtube.(?:.+?)\/(?:(?:playlist\?list=)([\w-]{34})(&[\w%;-]+(?:=[\w%;-]+)?)*)]/gi;
+    function convert(match, id, flags) {
+        if (flags) {
+            id += '?' + flags.replace(/&amp;/gi, '&');
+        }
+        return `<iframe allow="fullscreen" frameborder="0" src="https://www.youtube.com/embed/${id}"></iframe>`;
+    }
+    function convertPL(match, id, flags) {
+        if (flags) {
+            id += flags.replace(/&amp;/gi, '&');
+        }
+        return `<iframe allow="fullscreen" frameborder="0" src="https://www.youtube.com/embed/videoseries?list=${id}"></iframe>`;
+    }
+    return html
+        .replace(ytLongWatch, convert)
+        .replace(ytLongEmbed, convert)
+        .replace(ytShort, convert)
+        .replace(ytPlaylist, convertPL);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown-utils.js","sourceRoot":"","sources":["../../../../../../libs/markdown/src/lib/markdown-utils/markdown-utils.ts"],"names":[],"mappings":"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","sourcesContent":["export function removeLeadingHash(str: string): string {\n  if (str) {\n    return str.replace(/^#+/, '');\n  }\n  return '';\n}\n\nexport function removeTrailingHash(str: string | null): string {\n  if (str) {\n    return str.replace(/#.*/, '');\n  }\n  return '';\n}\n\nexport function genHeadingId(str: string): string {\n  if (str) {\n    return removeLeadingHash(\n      str\n        .replace(/(_|-|\\s)+/g, '')\n        // Remove certain special chars to create heading ids similar to those in github\n        // borrowed from showdown\n        // https://github.com/showdownjs/showdown/blob/develop/src/subParsers/makehtml/headers.js#L94\n        .replace(/[&+$,/:;=?@\"#{}|^¨~[\\]`\\\\*)(%.!'<>]/g, '')\n    ).toLowerCase();\n  }\n  return '';\n}\n\nexport function scrollToAnchor(\n  scope: HTMLElement,\n  anchor: string,\n  tryParent: boolean\n): boolean {\n  if (scope && anchor) {\n    const normalizedAnchor: string = genHeadingId(anchor);\n    let headingToJumpTo: Element | null = null;\n    const headingWithinComponent = scope.querySelector(\n      `[id=\"${normalizedAnchor}\"]`\n    );\n\n    if (headingWithinComponent) {\n      headingToJumpTo = headingWithinComponent;\n    } else if (tryParent) {\n      const parent = scope.parentElement;\n      if (parent) {\n        headingToJumpTo = parent.querySelector(`[id=\"${normalizedAnchor}\"]`);\n      }\n    }\n    if (headingToJumpTo) {\n      headingToJumpTo.scrollIntoView({ behavior: 'auto' });\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function isAnchorLink(anchor?: HTMLAnchorElement): boolean {\n  if (anchor) {\n    const href = anchor.getAttribute('href');\n    if (href) {\n      return href.startsWith('#');\n    }\n  }\n  return false;\n}\nconst RAW_GITHUB_HOSTNAME = 'raw.githubusercontent.com';\n\nexport function rawGithubHref(githubHref?: string): string {\n  if (githubHref) {\n    try {\n      const url: URL = new URL(githubHref);\n      if (url.hostname === RAW_GITHUB_HOSTNAME) {\n        return url.href;\n      } else if (isGithubHref(githubHref)) {\n        url.hostname = RAW_GITHUB_HOSTNAME;\n        url.pathname = url.pathname.split('/blob', 2).join('');\n        return url.href;\n      }\n    } catch {\n      return '';\n    }\n  }\n  return '';\n}\n\nexport function isGithubHref(href?: string): boolean {\n  try {\n    const temp: URL = new URL(href ?? '');\n    return temp.hostname === 'github.com';\n  } catch {\n    return false;\n  }\n}\n\nexport function isRawGithubHref(href: string = ''): boolean {\n  try {\n    const temp: URL = new URL(href);\n    return temp.hostname === RAW_GITHUB_HOSTNAME;\n  } catch {\n    return false;\n  }\n}\n\nexport function renderVideoElements(html: string): string {\n  const ytLongEmbed =\n    /!\\[(?:(?:https?:)?(?:\\/\\/)?)(?:(?:www)?.)?youtube.(?:.+?)\\/(?:(?:embed\\/)([\\w-]{11})(\\?[\\w%;-]+(?:=[\\w%;-]+)?(?:&[\\w%;-]+(?:=[\\w%;-]+)?)*)?)]/gi;\n  const ytLongWatch =\n    /!\\[(?:(?:https?:)?(?:\\/\\/)?)(?:(?:www)?.)?youtube.(?:.+?)\\/(?:(?:watch\\?v=)([\\w-]{11})(&[\\w%;-]+(?:=[\\w%;-]+)?)*)]/gi;\n  const ytShort =\n    /!\\[(?:(?:https?:)?(?:\\/\\/)?)?youtu.be\\/([\\w-]{11})\\??([\\w%;-]+(?:=[\\w%;-]+)?(?:&[\\w%;-]+(?:=[\\w%;-]+)?)*)?]/gi;\n  const ytPlaylist =\n    /!\\[(?:(?:https?:)?(?:\\/\\/)?)(?:(?:www)?.)?youtube.(?:.+?)\\/(?:(?:playlist\\?list=)([\\w-]{34})(&[\\w%;-]+(?:=[\\w%;-]+)?)*)]/gi;\n\n  function convert(match: string, id: string, flags: string): string {\n    if (flags) {\n      id += '?' + flags.replace(/&amp;/gi, '&');\n    }\n    return `<iframe allow=\"fullscreen\" frameborder=\"0\" src=\"https://www.youtube.com/embed/${id}\"></iframe>`;\n  }\n  function convertPL(match: string, id: string, flags: string): string {\n    if (flags) {\n      id += flags.replace(/&amp;/gi, '&');\n    }\n    return `<iframe allow=\"fullscreen\" frameborder=\"0\" src=\"https://www.youtube.com/embed/videoseries?list=${id}\"></iframe>`;\n  }\n\n  return html\n    .replace(ytLongWatch, convert)\n    .replace(ytLongEmbed, convert)\n    .replace(ytShort, convert)\n    .replace(ytPlaylist, convertPL);\n}\n"]}