ngx-showdown
Version:
A Angular (>=2) integration for Showdown
280 lines • 22.1 kB
JavaScript
import { Component, ElementRef, Input, Optional, SecurityContext } from '@angular/core';
import { DomSanitizer } from '@angular/platform-browser';
import { ShowdownConfig } from './showdown-config.provider';
import { ShowdownConverter } from './showdown-converter.provider';
/**
* @internal
*/
const MAP_OPTION = {
'': true,
true: true,
false: false
};
/**
* @internal
*/
let _toOption = (value) => MAP_OPTION.hasOwnProperty(value) ? MAP_OPTION[value] : value;
const ɵ0 = _toOption;
/**
* The options keys for the dynamic properties set.
* @internal
*/
const OPTIONS_PROPERTIES_KEYS = [
'backslashEscapesHTMLTags',
'completeHTMLDocument',
'disableForced4SpacesIndentedSublists',
'emoji',
'encodeEmails',
'ghCodeBlocks',
'ghCompatibleHeaderId',
'ghMentions',
'ghMentionsLink',
'headerLevelStart',
'literalMidWordAsterisks',
'literalMidWordUnderscores',
'metadata',
'noHeaderId',
'omitExtraWLInCodeBlocks',
'openLinksInNewWindow',
'parseImgDimensions',
'prefixHeaderId',
'rawHeaderId',
'rawPrefixHeaderId',
'requireSpaceBeforeHeadingText',
'simpleLineBreaks',
'simplifiedAutoLink',
'smartIndentationFix',
'smoothLivePreview',
'splitAdjacentBlockquotes',
'strikethrough',
'tables',
'tablesHeaderId',
'tasklists',
'underline'
];
/**
* A angular component for render `Markdown` to `HTML`.
*
* ### Example
*
* Setup as standalone
* ```typescript
* import { NgModule } from '@angular/core';
* import { ShowdownComponent } from 'ngx-showdown';
*
* @NgModule({
* declarations: [ ShowdownComponent ];
* })
* export class AppModule {}
* ```
*
* Bind markdown value and options object
* ```typescript
* import { Component } from '@angular/core';
* import * as Showdown from 'showdown';
*
* @Component({
* selector: 'some',
* template: '<showdown [value]="text" [options]="options"></showdown>'
* })
* export class SomeComponent {
* text: string = `
* # Some header
* ---
* **Some bold**
* `;
* options: Showdown.ShowdownOptions = { smartIndentationFix: true };
* // ...
* }
* ```
* Bind single option (it have properties for all showdown options).
* ```html
* <showdown emoji="true" noHeaderId># Some text :+1:</showdown>
* ```
*
* Set static markdown value.
* ```html
* <showdown value="___Some static value___" underline></showdown>
* ```
*
* Use as directive on anther element.
* ```html
* <div showdown="# Div Element" headerLevelStart="2"></div>
* ```
*
* Static markdown value in the element content.
* ```html
* <div>
* <showdown smartIndentationFix>
* # List:
* * a
* * A
* * b
* </showdown>
* </div>
* ```
*
* Set template reference variable.
* ```html
* <showdown #sd></showdown>
* ```
* Or
* ```html
* <div showdown #sd="showdown"></div>
* ```
*/
export class ShowdownComponent extends ShowdownConverter {
constructor(_elementRef, _domSanitizer, config) {
super(config);
this._elementRef = _elementRef;
this._domSanitizer = _domSanitizer;
}
/**
* Input alias to `value`.
*
* __Example :__
*
* ```html
* <div [showdown]="# Some Header"></div>
* ```
*
* Equivalent to
* ```html
* <showdown [value]="# Some Header"></showdown>
* ```
*/
set showdown(value) {
this.value = value;
}
/**
* The showdown options of the converter.
*
* __Example :__
*
* Bind options
* ```typescript
* import { Component } from '@angular/core';
* import * as Showdown from 'showdown';
*
* @Component({
* selector: `some`,
* template: `<showdown [options]="options"># Some Header<showdown>`
* })
* export class SomeComponent {
* options: Showdown.ShowdownOptions = {headerLevelStart: 3};
* // ...
* }
* ```
* Or
* ```html
* <showdown [options]="{smartIndentationFix: true}"> # Indentation Fix<showdown>
* ```
*/
get options() {
return this.getOptions();
}
set options(options) {
this.setOptions(options);
}
/**
* Enables html sanitize, it will sanitize the converter html output by [`DomSanitizer`](https://angular.io/api/platform-browser/DomSanitizer#sanitize).
*
* __Example :__
*
* ```typescript
* import { Component } from '@angular/core';
*
* @Component({
* selector: 'some',
* styles: [`.box { width: 95%; padding: 5px; border: 1px solid black;}`],
* template: `
* <h3>Input</h3>
* <textarea class="box" [(ngModel)]="text"></textarea>
* <input type="checkbox" [(ngModel)]="sanitize"/> <b>Sanitize</b>
* <h3>Markdown</h3>
* <pre class="box"><code>{{ text }}</code></pre>
* <h3>Preview</h3>
* <div class="box">
* <showdown #sd [value]="text" [sanitize]="sanitize"></showdown>
* </div>
* `;
* })
* export class SomeComponent {
* text: string = `# A cool link
* <a href="javascript:alert('Hello!')">click me</a>`;
* }
* ```
*/
set sanitize(sanitize) {
this._sanitize = _toOption(sanitize);
}
/**
* A angular lifecycle method, Use on init to check if it `content` type and load the element `content` to `value`.
* @internal
*/
ngOnInit() {
if (this.value === undefined && this._elementRef.nativeElement.innerHTML.trim() !== '') {
this.render(this._elementRef.nativeElement.innerHTML);
}
}
/**
* A angular lifecycle method, Use to call to render method after changes.
* @internal
*/
ngOnChanges() {
this.render();
}
/**
* Convert the markdown value of {@link ShowdownComponent#value} to html and set the html result to the element content.
*
* __Example :__
*
* ```html
* <textarea #textarea (change)="showdown.render(textarea.value)"/># Some Header</textarea>
* <showdown #showdown></showdown>
* ```
* @param value - A markdown value to render (it will override the current value of `ShowdownComponent#value`)
*/
render(value) {
if (typeof value === 'string') {
this.value = value;
}
if (typeof this.value === 'string') {
let result = this.makeHtml(this.value);
if (this._sanitize) {
result = this._domSanitizer.sanitize(SecurityContext.HTML, result);
}
this._elementRef.nativeElement.innerHTML = result;
}
}
}
ShowdownComponent.decorators = [
{ type: Component, args: [{
selector: 'showdown,[showdown]',
template: '<ng-content></ng-content>',
exportAs: 'showdown',
inputs: OPTIONS_PROPERTIES_KEYS
},] }
];
ShowdownComponent.ctorParameters = () => [
{ type: ElementRef },
{ type: DomSanitizer, decorators: [{ type: Optional }] },
{ type: ShowdownConfig, decorators: [{ type: Optional }] }
];
ShowdownComponent.propDecorators = {
value: [{ type: Input }],
showdown: [{ type: Input }],
options: [{ type: Input }],
sanitize: [{ type: Input }]
};
// Define options properties setter for angular directive and direct access
for (let key of OPTIONS_PROPERTIES_KEYS) {
Object.defineProperty(ShowdownComponent.prototype, key, {
set(value) {
this.setOption(key, _toOption(value));
},
configurable: true
});
}
export { ɵ0 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"showdown.component.js","sourceRoot":"","sources":["../../../src/showdown.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, Input, OnChanges, OnInit, Optional, SecurityContext } from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport * as Showdown from 'showdown';\nimport { ShowdownConfig } from './showdown-config.provider';\nimport { ShowdownConverter } from './showdown-converter.provider';\n\n/**\n * @internal\n */\nconst MAP_OPTION = {\n  '': true,\n  true: true,\n  false: false\n};\n\n/**\n * @internal\n */\nlet _toOption = (value: any) => MAP_OPTION.hasOwnProperty(value) ? MAP_OPTION[value] : value;\n\n/**\n * The options keys for the dynamic properties set.\n * @internal\n */\nconst OPTIONS_PROPERTIES_KEYS: string[] = [\n  'backslashEscapesHTMLTags',\n  'completeHTMLDocument',\n  'disableForced4SpacesIndentedSublists',\n  'emoji',\n  'encodeEmails',\n  'ghCodeBlocks',\n  'ghCompatibleHeaderId',\n  'ghMentions',\n  'ghMentionsLink',\n  'headerLevelStart',\n  'literalMidWordAsterisks',\n  'literalMidWordUnderscores',\n  'metadata',\n  'noHeaderId',\n  'omitExtraWLInCodeBlocks',\n  'openLinksInNewWindow',\n  'parseImgDimensions',\n  'prefixHeaderId',\n  'rawHeaderId',\n  'rawPrefixHeaderId',\n  'requireSpaceBeforeHeadingText',\n  'simpleLineBreaks',\n  'simplifiedAutoLink',\n  'smartIndentationFix',\n  'smoothLivePreview',\n  'splitAdjacentBlockquotes',\n  'strikethrough',\n  'tables',\n  'tablesHeaderId',\n  'tasklists',\n  'underline'\n];\n\n// For the options setter properties that dynamic definition (the code after the class)\nexport interface ShowdownComponent extends Showdown.ShowdownOptions {\n}\n\n/**\n * A angular component for render `Markdown` to `HTML`.\n *\n * ### Example\n *\n * Setup as standalone\n * ```typescript\n * import { NgModule } from '@angular/core';\n * import { ShowdownComponent } from 'ngx-showdown';\n *\n * @NgModule({\n *   declarations: [ ShowdownComponent ];\n * })\n * export class AppModule {}\n * ```\n *\n * Bind markdown value and options object\n * ```typescript\n * import { Component } from '@angular/core';\n * import * as Showdown from 'showdown';\n *\n * @Component({\n *   selector: 'some',\n *   template: '<showdown [value]=\"text\" [options]=\"options\"></showdown>'\n * })\n * export class SomeComponent {\n *   text: string = `\n *     # Some header\n *     ---\n *     **Some bold**\n *   `;\n *   options: Showdown.ShowdownOptions = { smartIndentationFix: true };\n *   // ...\n * }\n * ```\n * Bind single option (it have properties for all showdown options).\n * ```html\n * <showdown emoji=\"true\"  noHeaderId># Some text :+1:</showdown>\n * ```\n *\n * Set static markdown value.\n * ```html\n * <showdown value=\"___Some static value___\" underline></showdown>\n * ```\n *\n * Use as directive on anther element.\n * ```html\n * <div showdown=\"# Div Element\" headerLevelStart=\"2\"></div>\n * ```\n *\n * Static markdown value in the element content.\n * ```html\n * <div>\n *    <showdown smartIndentationFix>\n *       # List:\n *       * a\n *            * A\n *       * b\n *    </showdown>\n * </div>\n * ```\n *\n * Set template reference variable.\n * ```html\n * <showdown #sd></showdown>\n * ```\n * Or\n * ```html\n * <div showdown #sd=\"showdown\"></div>\n * ```\n */\n@Component({\n  selector: 'showdown,[showdown]',\n  template: '<ng-content></ng-content>',\n  exportAs: 'showdown',\n  inputs: OPTIONS_PROPERTIES_KEYS\n})\nexport class ShowdownComponent extends ShowdownConverter implements OnInit, OnChanges, Showdown.ShowdownOptions {\n\n  /**\n   * The input markdown value.\n   *\n   * __Example :__\n   *\n   * Set some static markdown value.\n   * ```html\n   * <showdown value=\"**Some bold value**\"></showdown>\n   * ```\n   *\n   * Bind property with markdown value.\n   * ```html\n   * <textarea [(ngModel)]=\"text\"></textarea>\n   * <showdown [value]=\"text\"></showdown>\n   * ```\n   */\n  @Input() value: string;\n\n  /**\n   * Input alias to `value`.\n   *\n   * __Example :__\n   *\n   * ```html\n   * <div [showdown]=\"# Some Header\"></div>\n   * ```\n   *\n   * Equivalent to\n   * ```html\n   * <showdown [value]=\"# Some Header\"></showdown>\n   * ```\n   */\n  @Input() set showdown(value: string) {\n    this.value = value;\n  }\n\n  /**\n   * The showdown options of the converter.\n   *\n   * __Example :__\n   *\n   * Bind options\n   * ```typescript\n   * import { Component } from '@angular/core';\n   * import * as Showdown from 'showdown';\n   *\n   * @Component({\n   *   selector: `some`,\n   *   template: `<showdown [options]=\"options\"># Some Header<showdown>`\n   * })\n   * export class SomeComponent {\n   *   options: Showdown.ShowdownOptions = {headerLevelStart: 3};\n   *   // ...\n   * }\n   * ```\n   * Or\n   * ```html\n   * <showdown [options]=\"{smartIndentationFix: true}\"> # Indentation Fix<showdown>\n   * ```\n   */\n  @Input()\n  get options(): Showdown.ShowdownOptions {\n    return this.getOptions();\n  }\n\n  set options(options: Showdown.ShowdownOptions) {\n    this.setOptions(options);\n  }\n\n  private _sanitize: boolean;\n\n  /**\n   * Enables html sanitize, it will sanitize the converter html output by [`DomSanitizer`](https://angular.io/api/platform-browser/DomSanitizer#sanitize).\n   *\n   * __Example :__\n   *\n   * ```typescript\n   * import { Component } from '@angular/core';\n   *\n   * @Component({\n   *   selector: 'some',\n   *   styles: [`.box { width: 95%; padding: 5px; border: 1px solid black;}`],\n   *   template: `\n   *     <h3>Input</h3>\n   *     <textarea class=\"box\" [(ngModel)]=\"text\"></textarea>\n   *     <input type=\"checkbox\" [(ngModel)]=\"sanitize\"/> <b>Sanitize</b>\n   *     <h3>Markdown</h3>\n   *     <pre class=\"box\"><code>{{ text }}</code></pre>\n   *     <h3>Preview</h3>\n   *     <div class=\"box\">\n   *       <showdown #sd [value]=\"text\" [sanitize]=\"sanitize\"></showdown>\n   *     </div>\n   *   `;\n   * })\n   * export class SomeComponent {\n   *    text: string = `# A cool link\n   * <a href=\"javascript:alert('Hello!')\">click me</a>`;\n   * }\n   * ```\n   */\n  @Input()\n  set sanitize(sanitize: boolean) {\n    this._sanitize = _toOption(sanitize);\n  }\n\n  constructor(private _elementRef: ElementRef, @Optional() private _domSanitizer?: DomSanitizer, @Optional() config?: ShowdownConfig) {\n    super(config);\n  }\n\n  /**\n   * A angular lifecycle method, Use on init to check if it `content` type and load the element `content` to `value`.\n   * @internal\n   */\n  ngOnInit(): void {\n    if (this.value === undefined && this._elementRef.nativeElement.innerHTML.trim() !== '') {\n      this.render(this._elementRef.nativeElement.innerHTML);\n    }\n  }\n\n  /**\n   * A angular lifecycle method, Use to call to render method after changes.\n   * @internal\n   */\n  ngOnChanges(): void {\n    this.render();\n  }\n\n  /**\n   * Convert the markdown value of {@link ShowdownComponent#value} to html and set the html result to the element content.\n   *\n   * __Example :__\n   *\n   * ```html\n   * <textarea #textarea (change)=\"showdown.render(textarea.value)\"/># Some Header</textarea>\n   * <showdown #showdown></showdown>\n   * ```\n   * @param value - A markdown value to render (it will override the current value of `ShowdownComponent#value`)\n   */\n  public render(value?: string): void {\n    if (typeof value === 'string') {\n      this.value = value;\n    }\n\n    if (typeof this.value === 'string') {\n      let result = this.makeHtml(this.value);\n\n      if (this._sanitize) {\n        result = this._domSanitizer.sanitize(SecurityContext.HTML, result);\n      }\n\n      this._elementRef.nativeElement.innerHTML = result;\n    }\n  }\n\n}\n\n// Define options properties setter for angular directive and direct access\nfor (let key of OPTIONS_PROPERTIES_KEYS) {\n  Object.defineProperty(ShowdownComponent.prototype, key, {\n    set(value: any): void {\n      this.setOption(key, _toOption(value));\n    },\n    configurable: true\n  });\n}\n"]}