@compodoc/compodoc
Version:
The missing documentation tool for your Angular application
1,329 lines (1,305 loc) • 2.04 MB
JavaScript
'use strict';
var fs = require('fs-extra');
var path = require('path');
var tsMorph = require('ts-morph');
var LiveServer = require('@compodoc/live-server');
var _ = require('lodash');
var ts = require('typescript');
var i18next = require('i18next');
var Handlebars = require('handlebars');
var semver = require('semver');
var htmlEntities = require('html-entities');
var JSON5 = require('json5');
var uuid = require('uuid');
var cosmiconfig = require('cosmiconfig');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
var path__namespace = /*#__PURE__*/_interopNamespace(path);
var LiveServer__namespace = /*#__PURE__*/_interopNamespace(LiveServer);
var ___namespace = /*#__PURE__*/_interopNamespace(_);
var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
var i18next__default = /*#__PURE__*/_interopDefaultLegacy(i18next);
var Handlebars__namespace = /*#__PURE__*/_interopNamespace(Handlebars);
var semver__namespace = /*#__PURE__*/_interopNamespace(semver);
var JSON5__namespace = /*#__PURE__*/_interopNamespace(JSON5);
/*! *****************************************************************************
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) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
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 __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 __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
var log = require('fancy-log');
var c = require('chalk');
var LEVEL;
(function (LEVEL) {
LEVEL[LEVEL["INFO"] = 0] = "INFO";
LEVEL[LEVEL["DEBUG"] = 1] = "DEBUG";
LEVEL[LEVEL["ERROR"] = 2] = "ERROR";
LEVEL[LEVEL["WARN"] = 3] = "WARN";
})(LEVEL || (LEVEL = {}));
var Logger = /** @class */ (function () {
function Logger() {
this.logger = log;
this.silent = true;
}
Logger.prototype.info = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (!this.silent) {
return;
}
this.logger(this.format.apply(this, __spreadArray([LEVEL.INFO], __read(args), false)));
};
Logger.prototype.error = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
this.logger(this.format.apply(this, __spreadArray([LEVEL.ERROR], __read(args), false)));
};
Logger.prototype.warn = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (!this.silent) {
return;
}
this.logger(this.format.apply(this, __spreadArray([LEVEL.WARN], __read(args), false)));
};
Logger.prototype.debug = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (!this.silent) {
return;
}
this.logger(this.format.apply(this, __spreadArray([LEVEL.DEBUG], __read(args), false)));
};
Logger.prototype.format = function (level) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var pad = function (s, l, z) {
if (z === void 0) { z = ''; }
return s + Array(Math.max(0, l - s.length + 1)).join(z);
};
var msg = args.join(' ');
if (args.length > 1) {
msg = pad(args.shift(), 15, ' ') + ": " + args.join(' ');
}
switch (level) {
case LEVEL.INFO:
msg = c.green(msg);
break;
case LEVEL.DEBUG:
msg = c.cyan(msg);
break;
case LEVEL.WARN:
msg = c.yellow(msg);
break;
case LEVEL.ERROR:
msg = c.red(msg);
break;
}
return [msg].join('');
};
return Logger;
}());
var logger = new Logger();
var COMPODOC_DEFAULTS = {
title: 'Application documentation',
additionalEntryName: 'Additional documentation',
additionalEntryPath: 'additional-documentation',
folder: './documentation/',
hostname: '127.0.0.1',
port: 8080,
theme: 'gitbook',
exportFormat: 'html',
exportFormatsSupported: ['html', 'json', 'pdf'],
base: '/',
defaultCoverageThreshold: 70,
defaultCoverageMinimumPerFile: 0,
coverageTestThresholdFail: true,
toggleMenuItems: ['all'],
navTabConfig: [],
disableSourceCode: false,
disableDomTree: false,
disableTemplateTab: false,
disableStyleTab: false,
disableGraph: false,
disableMainGraph: false,
disableCoverage: false,
disablePrivate: false,
disableProtected: false,
disableInternal: false,
disableLifeCycleHooks: false,
disableRoutesGraph: false,
disableDependencies: false,
disableProperties: false,
PAGE_TYPES: {
ROOT: 'root',
INTERNAL: 'internal'
},
gaSite: 'auto',
coverageTestShowOnlyFailed: false,
language: 'en-US',
maxSearchResults: 15
};
var Configuration = /** @class */ (function () {
function Configuration() {
this._pages = [];
this._mainData = {
output: COMPODOC_DEFAULTS.folder,
theme: COMPODOC_DEFAULTS.theme,
extTheme: '',
serve: false,
hostname: COMPODOC_DEFAULTS.hostname,
host: '',
port: COMPODOC_DEFAULTS.port,
open: false,
assetsFolder: '',
documentationMainName: COMPODOC_DEFAULTS.title,
documentationMainDescription: '',
base: COMPODOC_DEFAULTS.base,
hideGenerator: false,
hideDarkModeToggle: false,
hasFilesToCoverage: false,
modules: [],
readme: false,
changelog: '',
contributing: '',
license: '',
todo: '',
markdowns: [],
additionalPages: [],
pipes: [],
classes: [],
interfaces: [],
components: [],
controllers: [],
entities: [],
directives: [],
injectables: [],
interceptors: [],
guards: [],
miscellaneous: [],
routes: [],
tsconfig: '',
toggleMenuItems: COMPODOC_DEFAULTS.toggleMenuItems,
navTabConfig: [],
templates: '',
includes: '',
includesName: COMPODOC_DEFAULTS.additionalEntryName,
includesFolder: COMPODOC_DEFAULTS.additionalEntryPath,
disableSourceCode: COMPODOC_DEFAULTS.disableSourceCode,
disableDomTree: COMPODOC_DEFAULTS.disableDomTree,
disableTemplateTab: COMPODOC_DEFAULTS.disableTemplateTab,
disableStyleTab: COMPODOC_DEFAULTS.disableStyleTab,
disableGraph: COMPODOC_DEFAULTS.disableGraph,
disableMainGraph: COMPODOC_DEFAULTS.disableMainGraph,
disableCoverage: COMPODOC_DEFAULTS.disableCoverage,
disablePrivate: COMPODOC_DEFAULTS.disablePrivate,
disableInternal: COMPODOC_DEFAULTS.disableInternal,
disableProtected: COMPODOC_DEFAULTS.disableProtected,
disableLifeCycleHooks: COMPODOC_DEFAULTS.disableLifeCycleHooks,
disableRoutesGraph: COMPODOC_DEFAULTS.disableRoutesGraph,
disableSearch: false,
disableDependencies: COMPODOC_DEFAULTS.disableDependencies,
disableProperties: COMPODOC_DEFAULTS.disableProperties,
watch: false,
mainGraph: '',
coverageTest: false,
coverageTestThreshold: COMPODOC_DEFAULTS.defaultCoverageThreshold,
coverageTestThresholdFail: COMPODOC_DEFAULTS.coverageTestThresholdFail,
coverageTestPerFile: false,
coverageMinimumPerFile: COMPODOC_DEFAULTS.defaultCoverageMinimumPerFile,
unitTestCoverage: '',
unitTestData: undefined,
coverageTestShowOnlyFailed: COMPODOC_DEFAULTS.coverageTestShowOnlyFailed,
routesLength: 0,
angularVersion: '',
exportFormat: COMPODOC_DEFAULTS.exportFormat,
coverageData: {},
customFavicon: '',
customLogo: '',
packageDependencies: [],
packagePeerDependencies: [],
packageProperties: {},
gaID: '',
gaSite: '',
angularProject: false,
angularJSProject: false,
language: COMPODOC_DEFAULTS.language,
maxSearchResults: 15
};
}
Configuration.getInstance = function () {
if (!Configuration.instance) {
Configuration.instance = new Configuration();
}
return Configuration.instance;
};
Configuration.prototype.addPage = function (page) {
var indexPage = ___namespace.findIndex(this._pages, { name: page.name });
if (indexPage === -1) {
this._pages.push(page);
}
};
Configuration.prototype.hasPage = function (name) {
var indexPage = ___namespace.findIndex(this._pages, { name: name });
return indexPage !== -1;
};
Configuration.prototype.addAdditionalPage = function (page) {
this._mainData.additionalPages.push(page);
};
Configuration.prototype.getAdditionalPageById = function (id) {
return this._mainData.additionalPages.find(function (page) { return page.id === id; });
};
Configuration.prototype.resetPages = function () {
this._pages = [];
};
Configuration.prototype.resetAdditionalPages = function () {
this._mainData.additionalPages = [];
};
Configuration.prototype.resetRootMarkdownPages = function () {
var indexPage = ___namespace.findIndex(this._pages, { name: 'index' });
this._pages.splice(indexPage, 1);
indexPage = ___namespace.findIndex(this._pages, { name: 'changelog' });
this._pages.splice(indexPage, 1);
indexPage = ___namespace.findIndex(this._pages, { name: 'contributing' });
this._pages.splice(indexPage, 1);
indexPage = ___namespace.findIndex(this._pages, { name: 'license' });
this._pages.splice(indexPage, 1);
indexPage = ___namespace.findIndex(this._pages, { name: 'todo' });
this._pages.splice(indexPage, 1);
this._mainData.markdowns = [];
};
Object.defineProperty(Configuration.prototype, "pages", {
get: function () {
return this._pages;
},
set: function (pages) {
this._pages = [];
},
enumerable: false,
configurable: true
});
Object.defineProperty(Configuration.prototype, "markDownPages", {
get: function () {
return this._pages.filter(function (page) { return page.markdown; });
},
enumerable: false,
configurable: true
});
Object.defineProperty(Configuration.prototype, "mainData", {
get: function () {
return this._mainData;
},
set: function (data) {
Object.assign(this._mainData, data);
},
enumerable: false,
configurable: true
});
return Configuration;
}());
var Configuration$1 = Configuration.getInstance();
var AngularAPIs = require('../src/data/api-list.json');
var AngularApiUtil = /** @class */ (function () {
function AngularApiUtil() {
}
AngularApiUtil.getInstance = function () {
if (!AngularApiUtil.instance) {
AngularApiUtil.instance = new AngularApiUtil();
}
return AngularApiUtil.instance;
};
AngularApiUtil.prototype.findApi = function (type) {
var foundedApi;
___namespace.forEach(AngularAPIs, function (mainApi) {
___namespace.forEach(mainApi.items, function (api) {
if (api.title === type) {
foundedApi = api;
}
});
});
return {
source: 'external',
data: foundedApi
};
};
return AngularApiUtil;
}());
var AngularApiUtil$1 = AngularApiUtil.getInstance();
function extractLeadingText(string, completeTag) {
var tagIndex = string.indexOf(completeTag);
var leadingText = undefined;
var leadingTextRegExp = /\[(.+?)\]/g;
var leadingTextInfo = leadingTextRegExp.exec(string);
// did we find leading text, and if so, does it immediately precede the tag?
while (leadingTextInfo && leadingTextInfo.length) {
if (leadingTextInfo.index + leadingTextInfo[0].length === tagIndex) {
string = string.replace(leadingTextInfo[0], '');
leadingText = leadingTextInfo[1];
break;
}
leadingTextInfo = leadingTextRegExp.exec(string);
}
return {
leadingText: leadingText,
string: string
};
}
function splitLinkText(text) {
var linkText;
var target;
var splitIndex;
// if a pipe is not present, we split on the first space
splitIndex = text.indexOf('|');
if (splitIndex === -1) {
splitIndex = text.search(/\s/);
}
if (splitIndex !== -1) {
linkText = text.substr(splitIndex + 1);
// Normalize subsequent newlines to a single space.
linkText = linkText.replace(/\n+/, ' ');
target = text.substr(0, splitIndex);
}
return {
linkText: linkText,
target: target || text
};
}
var LinkParser = (function () {
var processTheLink = function (string, tagInfo, leadingText) {
var leading = extractLeadingText(string, tagInfo.completeTag), linkText, split, target, stringtoReplace;
linkText = leadingText ? leadingText : leading.leadingText || '';
split = splitLinkText(tagInfo.text);
target = split.target;
if (leading.leadingText !== undefined) {
stringtoReplace = '[' + leading.leadingText + ']' + tagInfo.completeTag;
}
else if (typeof split.linkText !== 'undefined') {
stringtoReplace = tagInfo.completeTag;
linkText = split.linkText;
}
if (linkText === '' || linkText == null || target == null) {
return string;
}
return string.replace(stringtoReplace, '[' + linkText + '](' + target + ')');
};
/**
* Convert
* {@link http://www.google.com|Google} or {@link https://github.com GitHub} or [Github]{@link https://github.com} to [Github](https://github.com)
*/
var replaceLinkTag = function (str) {
if (typeof str === 'undefined') {
return {
newString: ''
};
}
// new RegExp('\\[((?:.|\n)+?)]\\{@link\\s+((?:.|\n)+?)\\}', 'i').exec('ee [TO DO]{@link Todo} fo') -> "[TO DO]{@link Todo}", "TO DO", "Todo"
// new RegExp('\\{@link\\s+((?:.|\n)+?)\\}', 'i').exec('ee [TODO]{@link Todo} fo') -> "{@link Todo}", "Todo"
var tagRegExpLight = new RegExp('\\{@link\\s+((?:.|\n)+?)\\}', 'i'), tagRegExpFull = new RegExp('\\{@link\\s+((?:.|\n)+?)\\}', 'i'), tagRegExp, matches, previousString;
tagRegExp = str.indexOf(']{') !== -1 ? tagRegExpFull : tagRegExpLight;
function replaceMatch(replacer, tag, match, text, linkText) {
var matchedTag = {
completeTag: match,
tag: tag,
text: text
};
if (linkText) {
return replacer(str, matchedTag, linkText);
}
else {
return replacer(str, matchedTag);
}
}
do {
matches = tagRegExp.exec(str);
if (matches) {
previousString = str;
if (matches.length === 2) {
str = replaceMatch(processTheLink, 'link', matches[0], matches[1]);
}
if (matches.length === 3) {
str = replaceMatch(processTheLink, 'link', matches[0], matches[2], matches[1]);
}
}
} while (matches && previousString !== str);
return {
newString: str
};
};
var _resolveLinks = function (str) {
return replaceLinkTag(str).newString;
};
return {
resolveLinks: _resolveLinks
};
})();
var AngularLifecycleHooks;
(function (AngularLifecycleHooks) {
AngularLifecycleHooks[AngularLifecycleHooks["ngOnChanges"] = 0] = "ngOnChanges";
AngularLifecycleHooks[AngularLifecycleHooks["ngOnInit"] = 1] = "ngOnInit";
AngularLifecycleHooks[AngularLifecycleHooks["ngDoCheck"] = 2] = "ngDoCheck";
AngularLifecycleHooks[AngularLifecycleHooks["ngAfterContentInit"] = 3] = "ngAfterContentInit";
AngularLifecycleHooks[AngularLifecycleHooks["ngAfterContentChecked"] = 4] = "ngAfterContentChecked";
AngularLifecycleHooks[AngularLifecycleHooks["ngAfterViewInit"] = 5] = "ngAfterViewInit";
AngularLifecycleHooks[AngularLifecycleHooks["ngAfterViewChecked"] = 6] = "ngAfterViewChecked";
AngularLifecycleHooks[AngularLifecycleHooks["ngOnDestroy"] = 7] = "ngOnDestroy";
})(AngularLifecycleHooks || (AngularLifecycleHooks = {}));
var KindType;
(function (KindType) {
KindType["UNKNOWN"] = "";
KindType["STRING"] = "string";
KindType["NUMBER"] = "number";
KindType["ARRAY"] = "[]";
KindType["VOID"] = "void";
KindType["FUNCTION"] = "function";
KindType["TEMPLATE_LITERAL"] = "template literal type";
KindType["LITERAL"] = "literal type";
KindType["BOOLEAN"] = "boolean";
KindType["ANY"] = "any";
KindType["NULL"] = "null";
KindType["SYMBOL"] = "symbol";
KindType["NEVER"] = "never";
KindType["UNDEFINED"] = "undefined";
KindType["OBJECT"] = "object";
})(KindType || (KindType = {}));
var IsKindType = {
ANY: function (kind) {
return kindToType(kind) === KindType.ANY;
},
ARRAY: function (kind) {
return kindToType(kind) === KindType.ARRAY;
},
BOOLEAN: function (kind) {
return kindToType(kind) === KindType.BOOLEAN;
},
FUNCTION: function (kind) {
return kindToType(kind) === KindType.FUNCTION;
},
LITERAL: function (kind) {
return kindToType(kind) === KindType.LITERAL;
},
NEVER: function (kind) {
return kindToType(kind) === KindType.NEVER;
},
NULL: function (kind) {
return kindToType(kind) === KindType.NULL;
},
NUMBER: function (kind) {
return kindToType(kind) === KindType.NUMBER;
},
OBJECT: function (kind) {
return kindToType(kind) === KindType.OBJECT;
},
STRING: function (kind) {
return kindToType(kind) === KindType.STRING;
},
SYMBOL: function (kind) {
return kindToType(kind) === KindType.SYMBOL;
},
TEMPLATE_LITERAL: function (kind) {
return kindToType(kind) === KindType.TEMPLATE_LITERAL;
},
UNDEFINED: function (kind) {
return kindToType(kind) === KindType.UNDEFINED;
},
UNKNOWN: function (kind) {
return kindToType(kind) === KindType.UNKNOWN;
},
VOID: function (kind) {
return kindToType(kind) === KindType.VOID;
}
};
function kindToType(kind) {
var _type = KindType.UNKNOWN;
switch (kind) {
case tsMorph.SyntaxKind.StringKeyword:
case tsMorph.SyntaxKind.StringLiteral:
_type = KindType.STRING;
break;
case tsMorph.SyntaxKind.NumberKeyword:
case tsMorph.SyntaxKind.NumericLiteral:
_type = KindType.NUMBER;
break;
case tsMorph.SyntaxKind.ArrayType:
case tsMorph.SyntaxKind.ArrayLiteralExpression:
_type = KindType.ARRAY;
break;
case tsMorph.SyntaxKind.VoidKeyword:
_type = KindType.VOID;
break;
case tsMorph.SyntaxKind.FunctionType:
_type = KindType.FUNCTION;
break;
case tsMorph.SyntaxKind.TemplateLiteralType:
_type = KindType.TEMPLATE_LITERAL;
break;
case tsMorph.SyntaxKind.TypeLiteral:
_type = KindType.LITERAL;
break;
case tsMorph.SyntaxKind.BooleanKeyword:
_type = KindType.BOOLEAN;
break;
case tsMorph.SyntaxKind.AnyKeyword:
_type = KindType.ANY;
break;
case tsMorph.SyntaxKind.NullKeyword:
_type = KindType.NULL;
break;
case tsMorph.SyntaxKind.SymbolKeyword:
_type = KindType.SYMBOL;
break;
case tsMorph.SyntaxKind.NeverKeyword:
_type = KindType.NEVER;
break;
case tsMorph.SyntaxKind.UndefinedKeyword:
_type = KindType.UNDEFINED;
break;
case tsMorph.SyntaxKind.ObjectKeyword:
case tsMorph.SyntaxKind.ObjectLiteralExpression:
_type = KindType.OBJECT;
break;
}
return _type;
}
var tsany = ts__namespace;
// https://github.com/Microsoft/TypeScript/blob/v2.1.4/src/compiler/utilities.ts#L1423
function getJSDocCommentRanges(node, text) {
return tsany.getJSDocCommentRanges.apply(this, arguments);
}
var JsdocParserUtil = /** @class */ (function () {
function JsdocParserUtil() {
}
JsdocParserUtil.prototype.isVariableLike = function (node) {
if (node) {
switch (node.kind) {
case tsMorph.SyntaxKind.BindingElement:
case tsMorph.SyntaxKind.EnumMember:
case tsMorph.SyntaxKind.Parameter:
case tsMorph.SyntaxKind.PropertyAssignment:
case tsMorph.SyntaxKind.PropertyDeclaration:
case tsMorph.SyntaxKind.PropertySignature:
case tsMorph.SyntaxKind.ShorthandPropertyAssignment:
case tsMorph.SyntaxKind.VariableDeclaration:
return true;
}
}
return false;
};
JsdocParserUtil.prototype.isTopmostModuleDeclaration = function (node) {
if (node.nextContainer && node.nextContainer.kind === tsMorph.ts.SyntaxKind.ModuleDeclaration) {
var next = node.nextContainer;
if (node.name.end + 1 === next.name.pos) {
return false;
}
}
return true;
};
JsdocParserUtil.prototype.getRootModuleDeclaration = function (node) {
while (node.parent && node.parent.kind === tsMorph.ts.SyntaxKind.ModuleDeclaration) {
var parent = node.parent;
if (node.name.pos === parent.name.end + 1) {
node = parent;
}
else {
break;
}
}
return node;
};
JsdocParserUtil.prototype.getMainCommentOfNode = function (node, sourceFile) {
var description = '';
if (node.parent && node.parent.kind === tsMorph.ts.SyntaxKind.VariableDeclarationList) {
node = node.parent.parent;
}
else if (node.kind === tsMorph.ts.SyntaxKind.ModuleDeclaration) {
if (!this.isTopmostModuleDeclaration(node)) {
return null;
}
else {
node = this.getRootModuleDeclaration(node);
}
}
var comments = getJSDocCommentRanges(node, sourceFile.text);
if (comments && comments.length) {
var comment = void 0;
if (node.kind === tsMorph.ts.SyntaxKind.SourceFile) {
if (comments.length === 1) {
return null;
}
comment = comments[0];
}
else {
comment = comments[comments.length - 1];
}
description = sourceFile.text.substring(comment.pos, comment.end);
}
return description;
};
JsdocParserUtil.prototype.parseComment = function (text) {
var comment = '';
var shortText = 0;
function readBareLine(line) {
comment += '\n' + line;
if (line === '' && shortText === 0) ;
else if (line === '' && shortText === 1) {
shortText = 2;
}
else {
if (shortText === 2) {
comment += (comment === '' ? '' : '\n') + line;
}
}
}
var CODE_FENCE = /^\s*```(?!.*```)/;
var inCode = false;
var inExample = false; // first line with @example, end line with empty string or string or */
function readLine(line, index) {
line = line.replace(/^\s*\*? ?/, '');
line = line.replace(/\s*$/, '');
if (CODE_FENCE.test(line)) {
inCode = !inCode;
}
if (line.indexOf('@example') !== -1) {
inExample = true;
line = '```html';
}
if (inExample && line === '') {
inExample = false;
line = '```';
}
if (!inCode) {
var tag = /^@(\S+)/.exec(line);
var SeeTag = /^@see/.exec(line);
if (SeeTag) {
line = line.replace(/^@see/, 'See');
}
if (tag && !SeeTag) {
return;
}
}
readBareLine(line);
}
text = text.replace(/^\s*\/\*+/, '');
text = text.replace(/\*+\/\s*$/, '');
text.split(/\r\n?|\n/).length;
text.split(/\r\n?|\n/).forEach(readLine);
return comment;
};
JsdocParserUtil.prototype.getJSDocTags = function (node, kind) {
var e_1, _a;
var docs = this.getJSDocs(node);
if (docs) {
var result = [];
try {
for (var docs_1 = __values(docs), docs_1_1 = docs_1.next(); !docs_1_1.done; docs_1_1 = docs_1.next()) {
var doc = docs_1_1.value;
if (tsMorph.ts.isJSDocParameterTag(doc)) {
if (doc.kind === kind) {
result.push(doc);
}
}
else if (tsMorph.ts.isJSDoc(doc)) {
result.push.apply(result, __spreadArray([], __read(___namespace.filter(doc.tags, function (tag) { return tag.kind === kind; })), false));
}
else {
throw new Error('Unexpected type');
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (docs_1_1 && !docs_1_1.done && (_a = docs_1["return"])) _a.call(docs_1);
}
finally { if (e_1) throw e_1.error; }
}
return result;
}
};
JsdocParserUtil.prototype.getJSDocs = function (node) {
// TODO: jsDocCache is internal, see if there's a way around it
var cache = node.jsDocCache;
if (!cache) {
cache = this.getJSDocsWorker(node, []).filter(function (x) { return x; });
node.jsDocCache = cache;
}
return cache;
};
// Try to recognize this pattern when node is initializer
// of variable declaration and JSDoc comments are on containing variable statement.
// /**
// * @param {number} name
// * @returns {number}
// */
// var x = function(name) { return name.length; }
JsdocParserUtil.prototype.getJSDocsWorker = function (node, cache) {
var parent = node.parent;
var isInitializerOfVariableDeclarationInStatement = this.isVariableLike(parent) &&
parent.initializer === node &&
tsMorph.ts.isVariableStatement(parent.parent.parent);
var isVariableOfVariableDeclarationStatement = this.isVariableLike(node) && tsMorph.ts.isVariableStatement(parent.parent);
var variableStatementNode = isInitializerOfVariableDeclarationInStatement
? parent.parent.parent
: isVariableOfVariableDeclarationStatement
? parent.parent
: undefined;
if (variableStatementNode) {
cache = this.getJSDocsWorker(variableStatementNode, cache);
}
// Also recognize when the node is the RHS of an assignment expression
var isSourceOfAssignmentExpressionStatement = parent &&
parent.parent &&
tsMorph.ts.isBinaryExpression(parent) &&
parent.operatorToken.kind === tsMorph.SyntaxKind.EqualsToken &&
tsMorph.ts.isExpressionStatement(parent.parent);
if (isSourceOfAssignmentExpressionStatement) {
cache = this.getJSDocsWorker(parent.parent, cache);
}
var isModuleDeclaration = tsMorph.ts.isModuleDeclaration(node) && parent && tsMorph.ts.isModuleDeclaration(parent);
var isPropertyAssignmentExpression = parent && tsMorph.ts.isPropertyAssignment(parent);
if (isModuleDeclaration || isPropertyAssignmentExpression) {
cache = this.getJSDocsWorker(parent, cache);
}
// Pull parameter comments from declaring function as well
if (tsMorph.ts.isParameter(node)) {
cache = ___namespace.concat(cache, this.getJSDocParameterTags(node));
}
if (this.isVariableLike(node) && node.initializer) {
cache = ___namespace.concat(cache, node.initializer.jsDoc);
}
cache = ___namespace.concat(cache, node.jsDoc);
return cache;
};
JsdocParserUtil.prototype.getJSDocParameterTags = function (param) {
var func = param.parent;
var tags = this.getJSDocTags(func, tsMorph.SyntaxKind.JSDocParameterTag);
if (!param.name) {
// this is an anonymous jsdoc param from a `function(type1, type2): type3` specification
var i = func.parameters.indexOf(param);
var paramTags = ___namespace.filter(tags, function (tag) { return tsMorph.ts.isJSDocParameterTag(tag); });
if (paramTags && 0 <= i && i < paramTags.length) {
return [paramTags[i]];
}
}
else if (tsMorph.ts.isIdentifier(param.name)) {
var name_1 = param.name.text;
return ___namespace.filter(tags, function (tag) {
if (tsMorph.ts && tsMorph.ts.isJSDocParameterTag(tag)) {
var t = tag;
if (typeof t.parameterName !== 'undefined') {
return t.parameterName.text === name_1;
}
else if (typeof t.name !== 'undefined') {
if (typeof t.name.escapedText !== 'undefined') {
return t.name.escapedText === name_1;
}
}
}
});
}
else {
// TODO: it's a destructured parameter, so it should look up an "object type" series of multiple lines
// But multi-line object types aren't supported yet either
return undefined;
}
};
JsdocParserUtil.prototype.parseJSDocNode = function (node) {
var rawDescription = '';
if (typeof node.comment === 'string') {
rawDescription += node.comment;
}
else {
if (node.comment) {
var len = node.comment.length;
for (var i = 0; i < len; i++) {
var JSDocNode = node.comment[i];
switch (JSDocNode.kind) {
case tsMorph.SyntaxKind.JSDocComment:
rawDescription += JSDocNode.comment;
break;
case tsMorph.SyntaxKind.JSDocText:
rawDescription += JSDocNode.text;
break;
case tsMorph.SyntaxKind.JSDocLink:
if (JSDocNode.name) {
var text = JSDocNode.name.escapedText;
if (text === undefined &&
JSDocNode.name.left &&
JSDocNode.name.right) {
text =
JSDocNode.name.left.escapedText +
'.' +
JSDocNode.name.right.escapedText;
}
rawDescription += JSDocNode.text + '{@link ' + text + '}';
}
break;
}
}
}
}
return rawDescription;
};
return JsdocParserUtil;
}());
var getCurrentDirectory = tsMorph.ts.sys.getCurrentDirectory;
var useCaseSensitiveFileNames = tsMorph.ts.sys.useCaseSensitiveFileNames;
var newLine = tsMorph.ts.sys.newLine;
var marked$3 = require('marked').marked;
function getNewLine() {
return newLine;
}
function cleanNameWithoutSpaceAndToLowerCase(name) {
return name.toLowerCase().replace(/ /g, '-');
}
function getCanonicalFileName(fileName) {
return useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
}
var formatDiagnosticsHost = {
getCurrentDirectory: getCurrentDirectory,
getCanonicalFileName: getCanonicalFileName,
getNewLine: getNewLine
};
function markedtags(tags) {
var jsdocParserUtil = new JsdocParserUtil();
var mtags = tags;
___namespace.forEach(mtags, function (tag) {
var rawComment = jsdocParserUtil.parseJSDocNode(tag);
tag.comment = marked$3(LinkParser.resolveLinks(rawComment));
});
return mtags;
}
function mergeTagsAndArgs(args, jsdoctags) {
var margs = ___namespace.cloneDeep(args);
___namespace.forEach(margs, function (arg) {
arg.tagName = {
text: 'param'
};
if (jsdoctags) {
___namespace.forEach(jsdoctags, function (jsdoctag) {
if (jsdoctag.name && jsdoctag.name.text === arg.name) {
arg.tagName = jsdoctag.tagName;
arg.name = jsdoctag.name;
arg.comment = jsdoctag.comment;
arg.typeExpression = jsdoctag.typeExpression;
}
});
}
});
// Add example & returns & private
if (jsdoctags) {
___namespace.forEach(jsdoctags, function (jsdoctag) {
if (jsdoctag.tagName &&
(jsdoctag.tagName.text === 'example' || jsdoctag.tagName.text === 'private')) {
margs.push({
tagName: jsdoctag.tagName,
comment: jsdoctag.comment
});
}
if (jsdoctag.tagName &&
(jsdoctag.tagName.text === 'returns' || jsdoctag.tagName.text === 'return')) {
var ret = {
tagName: jsdoctag.tagName,
comment: jsdoctag.comment
};
if (jsdoctag.typeExpression && jsdoctag.typeExpression.type) {
ret.returnType = kindToType(jsdoctag.typeExpression.type.kind);
}
margs.push(ret);
}
});
}
return margs;
}
function readConfig(configFile) {
var result = tsMorph.ts.readConfigFile(configFile, tsMorph.ts.sys.readFile);
if (result.error) {
var message = tsMorph.ts.formatDiagnostics([result.error], formatDiagnosticsHost);
throw new Error(message);
}
return result.config;
}
function stripBom(source) {
if (source.charCodeAt(0) === 0xfeff) {
return source.slice(1);
}
return source;
}
function hasBom(source) {
return source.charCodeAt(0) === 0xfeff;
}
function cleanLifecycleHooksFromMethods(methods) {
var result = [];
if (typeof methods !== 'undefined') {
var i = 0;
var len = methods.length;
for (i; i < len; i++) {
if (!(methods[i].name in AngularLifecycleHooks)) {
result.push(methods[i]);
}
}
}
return result;
}
function cleanSourcesForWatch(list) {
return list.filter(function (element) {
if (fs__namespace.existsSync(process.cwd() + path__namespace.sep + element)) {
return element;
}
});
}
function getNamesCompareFn(name) {
/**
* Copyright https://github.com/ng-bootstrap/ng-bootstrap
*/
name = name || 'name';
var t = function (a, b) {
if (a[name]) {
return a[name].localeCompare(b[name]);
}
else {
return 0;
}
};
return t;
}
function isIgnore(member) {
var e_1, _a, e_2, _b;
if (member.jsDoc) {
try {
for (var _c = __values(member.jsDoc), _d = _c.next(); !_d.done; _d = _c.next()) {
var doc = _d.value;
if (doc.tags) {
try {
for (var _e = (e_2 = void 0, __values(doc.tags)), _f = _e.next(); !_f.done; _f = _e.next()) {
var tag = _f.value;
if (tag.tagName.text.indexOf('ignore') > -1) {
return true;
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_f && !_f.done && (_b = _e["return"])) _b.call(_e);
}
finally { if (e_2) throw e_2.error; }
}
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_d && !_d.done && (_a = _c["return"])) _a.call(_c);
}
finally { if (e_1) throw e_1.error; }
}
}
return false;
}
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
Object.defineProperty(Array.prototype, 'includes', {
value: function (searchElement, fromIndex) {
if (this == null) {
throw new TypeError('"this" is null or not defined');
}
// 1. Let O be ? ToObject(this value).
var o = Object(this);
// 2. Let len be ? ToLength(? Get(O, "length")).
var len = o.length >>> 0;
// 3. If len is 0, return false.
if (len === 0) {
return false;
}
// 4. Let n be ? ToInteger(fromIndex).
// (If fromIndex is undefined, this step produces the value 0.)
var n = fromIndex | 0;
// 5. If n ≥ 0, then
// a. Let k be n.
// 6. Else n < 0,
// a. Let k be len + n.
// b. If k < 0, let k be 0.
var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
function sameValueZero(x, y) {
return (x === y ||
(typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y)));
}
// 7. Repeat, while k < len
while (k < len) {
// a. Let elementK be the result of ? Get(O, ! ToString(k)).
// b. If SameValueZero(searchElement, elementK) is true, return true.
if (sameValueZero(o[k], searchElement)) {
return true;
}
// c. Increase k by 1.
k++;
}
// 8. Return false
return false;
}
});
}
function findMainSourceFolder(files) {
var mainFolder = '';
var mainFolderCount = 0;
var rawFolders = files.map(function (filepath) {
var shortPath = filepath.replace(process.cwd() + path__namespace.sep, '');
return path__namespace.dirname(shortPath);
});
var folders = {};
rawFolders = ___namespace.uniq(rawFolders);
for (var i = 0; i < rawFolders.length; i++) {
var sep = rawFolders[i].split(path__namespace.sep);
sep.forEach(function (folder) {
if (folders[folder]) {
folders[folder] += 1;
}
else {
folders[folder] = 1;
}
});
}
for (var f in folders) {
if (folders[f] > mainFolderCount) {
mainFolderCount = folders[f];
mainFolder = f;
}
}
return mainFolder;
}
// Create a compilerHost object to allow the compiler to read and write files
function compilerHost(transpileOptions) {
var inputFileName = transpileOptions.fileName || (transpileOptions.jsx ? 'module.tsx' : 'module.ts');
var toReturn = {
getSourceFile: function (fileName) {
if (fileName.lastIndexOf('.ts') !== -1 || fileName.lastIndexOf('.js') !== -1) {
if (fileName === 'lib.d.ts') {
return undefined;
}
if (fileName.substr(-5) === '.d.ts') {
return undefined;
}
if (path__namespace.isAbsolute(fileName) === false) {
fileName = path__namespace.join(transpileOptions.tsconfigDirectory, fileName);
}
if (!fs__namespace.existsSync(fileName)) {
return undefined;
}
var libSource = '';
try {
libSource = fs__namespace.readFileSync(fileName).toString();
if (hasBom(libSource)) {
libSource = stripBom(libSource);
}
}
catch (e) {
logger.debug(e, fileName);
}
return tsMorph.ts.createSourceFile(fileName, libSource, transpileOptions.target, false);
}
return undefined;
},
writeFile: function (name, text) { },
getDefaultLibFileName: function () { return 'lib.d.ts'; },
useCaseSensitiveFileNames: function () { return false; },
getCanonicalFileName: function (fileName) { return fileName; },
getCurrentDirectory: function () { return ''; },
getNewLine: function () { return '\n'; },
fileExists: function (fileName) { return fileName === inputFileName; },
readFile: function () { return ''; },
directoryExists: function () { return true; },
getDirectories: function () { return []; }
};
return toReturn;
}
function detectIndent(str, count) {
var stripIndent = function (stripedString) {
var match = stripedString.match(/^[ \t]*(?=\S)/gm);
if (!match) {
return stripedString;
}
// TODO: use spread operator when targeting Node.js 6
var indent = Math.min.apply(Math, match.map(function (x) { return x.length; })); // eslint-disable-line
var re = new RegExp("^[ \\t]{" + indent + "}", 'gm');
return indent > 0 ? stripedString.replace(re, '') : stripedString;
};
var repeating = function (n, repeatString) {
repeatString = repeatString === undefined ? ' ' : repeatString;
if (typeof repeatString !== 'string') {
throw new TypeError("Expected `input` to be a `string`, got `" + typeof repeatString + "`");
}
if (n < 0) {
throw new TypeError("Expected `count` to be a positive finite number, got `" + n + "`");
}
var ret = '';
do {
if (n & 1) {
ret += repeatString;
}
repeatString += repeatString;
} while ((n >>= 1));
return ret;
};
var indentString = function (indentedString, indentCount) {
var indent = ' ';
indentCount = indentCount === undefined ? 1 : indentCount;
if (typeof indentedString !== 'string') {
throw new TypeError("Expected `input` to be a `string`, got `" + typeof indentedString + "`");
}
if (typeof indentCount !== 'number') {
throw new TypeError("Expected `count` to be a `number`, got `" + typeof indentCount + "`");
}
if (typeof indent !== 'string') {
throw new TypeError("Expected `indent` to be a `string`, got `" + typeof indent + "`");
}
if (indentCount === 0) {
return indentedString;
}
indent = indentCount > 1 ? repeating(indentCount, indent) : indent;
return indentedString.replace(/^(?!\s*$)/gm, indent);
};
return indentString(stripIndent(str), count || 0);
}
var IGNORED_DIRECTORIES = ['.git', 'node_modules'];
function ignoreDirectory(dir) {
var base = path__namespace.basename(dir);
if (IGNORED_DIRECTORIES.includes(base))
return true;
try {
fs__namespace.accessSync(dir, fs__namespace.constants.W_OK);
}
catch (err) {
logger.warn('Ignoring inaccessible folder', dir);
return true;
}
return false;
}
var traverse$3 = require('traverse');
var DependenciesEngine = /** @class */ (function () {
function DependenciesEngine() {
this.miscellaneous = {
variables: [],
functions: [],
typealiases: [],
enumerations: [],
groupedVariables: [],
groupedFunctions: [],
groupedEnumerations: [],
groupedTypeAliases: []
};
}
DependenciesEngine.getInstance = function () {
if (!DependenciesEngine.instance) {
DependenciesEngine.instance = new DependenciesEngine();
}
return DependenciesEngine.instance;
};
DependenciesEngine.prototype.updateModulesDeclarationsExportsTypes = function () {
var _this = this;
var mergeTypes = function (entry) {
var directive = _this.findInCompodocDependencies(entry.name, _this.directives, entry.file);
if (typeof directive.data !== 'undefined') {
entry.type = 'directive';
entry.id = directive.data.id;
}
var component = _this.findInCompodocDependencies(entry.name, _this.components, entry.file);
if (typeof component.data !== 'undefined') {
entry.type = 'component';
entry.id = component.data.id;
}
var pipe = _this.findInCompodocDe