ngx-showdown
Version:
A Angular (>=2) integration for Showdown
974 lines (960 loc) • 35.3 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('showdown'), require('@angular/platform-browser'), require('@angular/common/http')) :
typeof define === 'function' && define.amd ? define('ngx-showdown', ['exports', '@angular/core', 'showdown', '@angular/platform-browser', '@angular/common/http'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['ngx-showdown'] = {}, global.ng.core, global.showdown, global.ng.platformBrowser, global.ng.common.http));
}(this, (function (exports, core, Showdown, platformBrowser, http) { 'use strict';
/**
* @internal
*/
var hasOwnProperty = {}.hasOwnProperty;
/**
* A config provider
*
* ### Example
*
* Set custom config provider.
* ```typescript
* import { NgModel } from '@angular/core';
* import { ShowdownModule, ShowdownConfig } from 'ngx-showdown';
*
* export class MyShowdownConfig extends ShowdownConfig {
* emoji = true;
* underscore = false;
* flavor = 'github';
* }
*
* @NgModel({
* imports: [ ShowdownModule ],
* providers: [ {provide: ShowdownConfig, useClass: MyConverterOptions} ]
* })
* export class AppModule {}
* ```
*/
var ShowdownConfig = /** @class */ (function () {
function ShowdownConfig(options) {
this.merge(options);
}
/**
* Merge options
*
* @param options - A options object to merge.
*/
ShowdownConfig.prototype.merge = function (options) {
for (var key in options) {
if (hasOwnProperty.call(options, key)) {
this[key] = options[key];
}
}
};
return ShowdownConfig;
}());
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); };
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
}) : (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
;
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n])
i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try {
step(g[n](v));
}
catch (e) {
settle(q[0][3], e);
} }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
}
else {
cooked.raw = raw;
}
return cooked;
}
;
var __setModuleDefault = Object.create ? (function (o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function (o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
/**
* @internal
*/
var hasOwnProperty$1 = {}.hasOwnProperty;
/**
* ### Example
*
* Setup as standalone
* ```typescript
* import { NgModule } from '@angular/core';
* import { ShowdownConverter } from 'ngx-showdown';
*
* @NgModule({
* providers: [ ShowdownConverter ];
* })
* export class AppModule {}
* ```
*
* Use the converter instance.
* ```typescript
* import { Injectable } from '@angular/core';
* import { ShowdownConverter } from 'ngx-showdown';
*
* @Injectable()
* export class SomeService {
* constructor(showdownConverter: ShowdownConverter) {
* let markdown: string = "**Some**";
* let html: string = showdownConverter.makeHtml(markdown);
* console.log(`some:\nmarkdown: ${markdown)\nhtml: ${html}\n`);
* }
* }
* ```
*/
var ShowdownConverter = /** @class */ (function (_super) {
__extends(ShowdownConverter, _super);
function ShowdownConverter(config) {
var _this = _super.call(this, config && { extensions: config.extensions }) || this;
_this.setFlavor((config && config.flavor) || 'vanilla');
_this.setOptions(config);
return _this;
}
/**
* Set options to the converter.
*
* @param options - A options object to set.
*/
ShowdownConverter.prototype.setOptions = function (options) {
for (var key in options) {
if (hasOwnProperty$1.call(options, key)) {
this.setOption(key, options[key]);
}
}
};
return ShowdownConverter;
}(Showdown.Converter));
ShowdownConverter.decorators = [
{ type: core.Injectable }
];
ShowdownConverter.ctorParameters = function () { return [
{ type: ShowdownConfig, decorators: [{ type: core.Optional }] }
]; };
var e_1, _a;
/**
* @internal
*/
var MAP_OPTION = {
'': true,
true: true,
false: false
};
/**
* @internal
*/
var _toOption = function (value) { return MAP_OPTION.hasOwnProperty(value) ? MAP_OPTION[value] : value; };
var ɵ0 = _toOption;
/**
* The options keys for the dynamic properties set.
* @internal
*/
var 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>
* ```
*/
var ShowdownComponent = /** @class */ (function (_super) {
__extends(ShowdownComponent, _super);
function ShowdownComponent(_elementRef, _domSanitizer, config) {
var _this = _super.call(this, config) || this;
_this._elementRef = _elementRef;
_this._domSanitizer = _domSanitizer;
return _this;
}
Object.defineProperty(ShowdownComponent.prototype, "showdown", {
/**
* Input alias to `value`.
*
* __Example :__
*
* ```html
* <div [showdown]="# Some Header"></div>
* ```
*
* Equivalent to
* ```html
* <showdown [value]="# Some Header"></showdown>
* ```
*/
set: function (value) {
this.value = value;
},
enumerable: false,
configurable: true
});
Object.defineProperty(ShowdownComponent.prototype, "options", {
/**
* 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: function () {
return this.getOptions();
},
set: function (options) {
this.setOptions(options);
},
enumerable: false,
configurable: true
});
Object.defineProperty(ShowdownComponent.prototype, "sanitize", {
/**
* 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: function (sanitize) {
this._sanitize = _toOption(sanitize);
},
enumerable: false,
configurable: true
});
/**
* A angular lifecycle method, Use on init to check if it `content` type and load the element `content` to `value`.
* @internal
*/
ShowdownComponent.prototype.ngOnInit = function () {
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
*/
ShowdownComponent.prototype.ngOnChanges = function () {
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`)
*/
ShowdownComponent.prototype.render = function (value) {
if (typeof value === 'string') {
this.value = value;
}
if (typeof this.value === 'string') {
var result = this.makeHtml(this.value);
if (this._sanitize) {
result = this._domSanitizer.sanitize(core.SecurityContext.HTML, result);
}
this._elementRef.nativeElement.innerHTML = result;
}
};
return ShowdownComponent;
}(ShowdownConverter));
ShowdownComponent.decorators = [
{ type: core.Component, args: [{
selector: 'showdown,[showdown]',
template: '<ng-content></ng-content>',
exportAs: 'showdown',
inputs: OPTIONS_PROPERTIES_KEYS
},] }
];
ShowdownComponent.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: platformBrowser.DomSanitizer, decorators: [{ type: core.Optional }] },
{ type: ShowdownConfig, decorators: [{ type: core.Optional }] }
]; };
ShowdownComponent.propDecorators = {
value: [{ type: core.Input }],
showdown: [{ type: core.Input }],
options: [{ type: core.Input }],
sanitize: [{ type: core.Input }]
};
var _loop_1 = function (key) {
Object.defineProperty(ShowdownComponent.prototype, key, {
set: function (value) {
this.setOption(key, _toOption(value));
},
configurable: true
});
};
try {
// Define options properties setter for angular directive and direct access
for (var OPTIONS_PROPERTIES_KEYS_1 = __values(OPTIONS_PROPERTIES_KEYS), OPTIONS_PROPERTIES_KEYS_1_1 = OPTIONS_PROPERTIES_KEYS_1.next(); !OPTIONS_PROPERTIES_KEYS_1_1.done; OPTIONS_PROPERTIES_KEYS_1_1 = OPTIONS_PROPERTIES_KEYS_1.next()) {
var key = OPTIONS_PROPERTIES_KEYS_1_1.value;
_loop_1(key);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (OPTIONS_PROPERTIES_KEYS_1_1 && !OPTIONS_PROPERTIES_KEYS_1_1.done && (_a = OPTIONS_PROPERTIES_KEYS_1.return)) _a.call(OPTIONS_PROPERTIES_KEYS_1);
}
finally { if (e_1) throw e_1.error; }
}
/**
* A angular directive to `ShowdownComponent` for make http request of markdown content.
*
* ### Example
*
* Setup as standalone
* ```typescript
* import { NgModule } from '@angular/core';
* import { HttpClientModule } from '@angular/common/http';
* import { ShowdownComponent, SourceDirective } from 'ngx-showdown';
*
* @NgModule({
* declarations: [ ShowdownComponent, SourceDirective ],
* imports: [ HttpClientModule ]
* })
* export class AppModule {}
* ```
*
* Bind url `src` directive
* ```typescript
* import { Component } from '@angular/core';
*
* @Component({
* selector: 'some',
* template: '<showdown [src]="url" smartIndentationFix>**Loading...**</showdown>
* })
* class SomeComponent {
* url: string = 'https://unpkg.com/ngx-showdown/README.md';
* // ...
* }
* ```
*
* Set static url
* ```html
* <showdown src="README.md" [options]="{noHeaderId: true}"></showdown>
* ```
*
* Set template reference variable
* ```html
* <showdown #source="source" src="README.md"></showdown>
* ```
*
* Listening to `error` events.
* ```html
* <showdown #sd src="http://url.error" (error)="sd.render('# '+$event.message)"></showdown>
* ```
*/
var SourceDirective = /** @class */ (function () {
function SourceDirective(_showdownComponent, _http) {
this._showdownComponent = _showdownComponent;
this._http = _http;
/**
* On error occur.
*
* __Example :__
*
* ```html
* <input type="text" placeholder="url" [(ngModel)]="url"/>
* <showdown [src]="url" (error)="sd.render('# Error\n> '+$event.message)">**Loading...**</showdown>
* ```
*/
this.error = new core.EventEmitter();
}
/**
* A angular lifecycle method, Use to call to `load` method on src init/changes
* @internal
*/
SourceDirective.prototype.ngOnChanges = function () {
this.load();
};
/**
* Load the markdown content of {@link SourceDirective#src} url to {@link ShowdownComponent#value}.
*
* __Example :__
*
* ```html
* <input type="text" #url value="source.src" placeholder="Url" />
* <button (click)="source.load(url.value)">Load</button>
* <showdown #source="source" src="https://unpkg.com/ngx-showdown/README.md"></showdown>
* ```
* @param url - A url of markdown content to load (it will override the current url of `SourceDirective#src`)
*/
SourceDirective.prototype.load = function (url) {
var _this = this;
if (url) {
this.src = url;
}
if (this.src) {
this
._http
.get(this.src, { responseType: 'text' })
.subscribe(function (response) {
_this._showdownComponent.render(response);
}, function (error) {
_this.error.emit(error);
});
}
};
return SourceDirective;
}());
SourceDirective.decorators = [
{ type: core.Directive, args: [{
selector: 'showdown[src],[showdown][src]',
exportAs: 'source'
},] }
];
SourceDirective.ctorParameters = function () { return [
{ type: ShowdownComponent },
{ type: http.HttpClient }
]; };
SourceDirective.propDecorators = {
src: [{ type: core.Input }],
error: [{ type: core.Output }]
};
/**
* A angular pipe to transform `Markdown` to `HTML`.
*
* ### Example
*
* Setup as standalone
* ```typescript
* import { NgModule } from '@angular/core';
* import { ShowdownPipe } from 'ngx-showdown';
*
* @NgModule({
* declarations: [ ShowdownPipe ];
* })
* export class AppModule {}
* ```
*
* Transform markdown value to html.
* ```html
* <input type="text" placeholder="Name" [(ngModel)]="name"/>
* <div [innerHTML]="'**Hello '+(name || 'nobody')+'!**' | showdown">
* ```
*
* Transform markdown value to html with `options`.
* ```typescript
* import * as Showdown from 'showdown';
*
* @Component({
* selector: 'some',
* template: `<div innerHTML="{{ text | showdown: options }}"></div>`
* })
* export class SomeComponent {
* text: string = "__Some Underline__";
* options: Showdown.ShowdownOptions = { underline: true };
* // ...
* }
* ```
*/
var ShowdownPipe = /** @class */ (function (_super) {
__extends(ShowdownPipe, _super);
function ShowdownPipe() {
return _super !== null && _super.apply(this, arguments) || this;
}
/**
* Transform markdown value to html.
*
* @param value - The markdown value to transform to html.
* @param options - A `Showdown` converter options.
* @returns Returns the transform result of `value` to html.
*/
ShowdownPipe.prototype.transform = function (value, options) {
this.setOptions(options);
return this.makeHtml(value);
};
return ShowdownPipe;
}(ShowdownConverter));
ShowdownPipe.decorators = [
{ type: core.Pipe, args: [{
name: 'showdown',
pure: false
},] }
];
/**
* @internal
*/
var DECLARATIONS = [
ShowdownComponent,
ShowdownPipe,
SourceDirective
];
/**
* ### Example
*
* Add `ShowdownModule` to app `imports`.
* ```typescript
* import { NgModule } from '@angular/core';
* import { ShowdownModule } from 'ngx-showdown';
*
* @NgModule({
* imports: [ ShowdownModule ];
* })
* export class AppModule {}
* ```
*/
var ShowdownModule = /** @class */ (function () {
function ShowdownModule() {
}
/**
* __Example :__
*
* Add `ShowdownModule` to app `imports` with config.
* ```typescript
* import { NgModule } from '@angular/core';
* import { ShowdownModule } from 'ngx-showdown';
*
* @NgModule({
* imports: [ ShowdownModule.forRoot({
* smartIndentationFix: true,
* foo: 'bar',
* flavor: 'github',
* extensions: [ {type:'listener', listeners: {'codeBlocks.after': console.log}} ]
* }) ];
* })
* export class AppModule {}
* ```
* @param config - A root converter config for all converter instances.
*/
ShowdownModule.forRoot = function (config) {
return {
ngModule: ShowdownModule,
providers: [{ provide: ShowdownConfig, useValue: config }]
};
};
return ShowdownModule;
}());
ShowdownModule.decorators = [
{ type: core.NgModule, args: [{
declarations: DECLARATIONS,
providers: [ShowdownConverter],
exports: DECLARATIONS
},] }
];
/**
* Generated bundle index. Do not edit.
*/
exports.ShowdownComponent = ShowdownComponent;
exports.ShowdownConfig = ShowdownConfig;
exports.ShowdownConverter = ShowdownConverter;
exports.ShowdownModule = ShowdownModule;
exports.ShowdownPipe = ShowdownPipe;
exports.SourceDirective = SourceDirective;
exports.ɵ0 = ɵ0;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=ngx-showdown.umd.js.map