@ui5/builder 3.0.6 → 3.0.8

package/lib/processors/jsdoc/lib/ui5/template/publish.cjs

@@ -12,7 +12,6 @@
 "use strict";
 
 /* imports */
-const template = require('jsdoc/template');
 const helper = require('jsdoc/util/templateHelper');
 const fs = require('jsdoc/fs');
 const doclet = require('jsdoc/doclet');
@@ -77,30 +76,15 @@ const MY_TEMPLATE_NAME = "ui5",
 		}
 	];
 
-const	rSecurityTags = new RegExp(A_SECURITY_TAGS.map(function($) {return $.name.toLowerCase(); }).join('|'), "i");
-	//debug(A_SECURITY_TAGS.map(function($) {return $.name; }).join('|'));
-
 const templatesConf = (env.conf.templates || {}),
-	templateConf = templatesConf[MY_TEMPLATE_NAME] || templatesConf[MY_ALT_TEMPLATE_NAME] || {},
-	pluginConf = templateConf;
+	templateConf = templatesConf[MY_TEMPLATE_NAME] || templatesConf[MY_ALT_TEMPLATE_NAME] || {};
 
 let conf = {};
 
-let view;
-
 let __symbols;
 let __longnames;
 let __missingLongnames = {};
 
-/**
- * Maps the symbol 'longname's to the unique filename that contains the documentation of that symbol.
- * This map is maintained to deal with names that only differ in case (e.g. the namespace sap.ui.model.type and the class sap.ui.model.Type).
- */
-let __uniqueFilenames = {};
-
-/* shortcut for Object.prototype.hasOwnProperty.call(obj, prop) */
-const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
-
 function merge(target, source) {
 	if ( source != null ) {
 		// simple single source merge
@@ -121,13 +105,28 @@ function merge(target, source) {
 }
 
 function lookup(key) {
-	if ( !Object.prototype.hasOwnProperty.call(__longnames, key) ) {
+	if ( !Object.hasOwn(__longnames, key) ) {
 		__missingLongnames[key] = (__missingLongnames[key] || 0) + 1;
 		__longnames[key] = __symbols.find((symbol) => symbol.longname === key);
 	}
 	return __longnames[key];
 }
 
+function createSymbol(longname, lines = []) {
+	const comment = [
+		"@name " + longname,
+		... lines
+	];
+
+	const symbol = new doclet.Doclet("/**\n * " + comment.join("\n * ") + "\n */", {});
+	symbol.__ui5 = {};
+
+	__longnames[longname] = symbol;
+	__symbols.push(symbol);
+
+	return symbol;
+}
+
 const externalSymbols = {};
 
 function loadExternalSymbols(apiJsonFolder) {
@@ -186,253 +185,14 @@ function supportsInheritance($) {
  * In the less perfect documentation build, the criterion 'whose parents are all namespaces' is ignored
  */
 function isFirstClassSymbol($) {
-	return /^(namespace|interface|class|typedef)$/.test($.kind) || ($.kind === 'member' && $.isEnum || isModuleExport($) )/* isNonEmptyNamespace($) */;
+	return (
+		/^(namespace|interface|class|typedef)$/.test($.kind)
+		|| $.kind === 'member' && $.isEnum
+		|| ['function', 'member'].includes($.kind) && isModuleExport($)
+	)/* isNonEmptyNamespace($) */;
 }
 
-
-// ---- Version class -----------------------------------------------------------------------------------------------------------------------------------------------------------
-
-const Version = (function() {
-
-	const rVersion = /^[0-9]+(?:\.([0-9]+)(?:\.([0-9]+))?)?(.*)$/;
-
-	function norm(v) {
-		v = parseInt(v);
-		return isNaN(v) ? 0 : v;
-	}
-
-	function compare(v1, v2) {
-		if ( v1 !== v2 ) {
-			return v1 < v2 ? -1 : 1;
-		}
-		return 0;
-	}
-
-	/**
-	 * Creates a Version object from the given version string.
-	 *
-	 * @param {string} versionStr A dot-separated version string
-	 *
-	 * @classdesc Represents a version consisting of major, minor, patch version and suffix,
-	 * e.g. '1.2.7-SNAPSHOT'. All parts after the major version are optional.
-	 * @class
-	 */
-	class Version {
-
-		constructor(versionStr) {
-			const match = rVersion.exec(versionStr) || [];
-
-			Object.defineProperty(this, "major", {
-				enumerable: true,
-				value: norm(match[0])
-			});
-			Object.defineProperty(this, "minor", {
-				enumerable: true,
-				value: norm(match[1])
-			});
-			Object.defineProperty(this, "patch", {
-				enumerable: true,
-				value: norm(match[2])
-			});
-			Object.defineProperty(this, "suffix", {
-				enumerable: true,
-				value: String(match[3] || "")
-			});
-		}
-
-		toMajorMinor() {
-			return new Version(this.major + "." + this.minor);
-		}
-
-		toString() {
-			return this.major + "." + this.minor + "." + this.patch + this.suffix;
-		}
-
-		compareTo(other) {
-			return (
-				this.major - other.major
-				|| this.minor - other.minor
-				|| this.patch - other.patch
-				|| compare(this.suffix, other.suffix)
-			);
-		}
-
-	}
-
-	return Version;
-
-}());
-
-// ---- Link class --------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-//TODO move to separate module
-
-const Link = (function() {
-
-	const missingTypes = {};
-
-	function _makeLink(href, target, tooltip, text) {
-		return '<a' +
-			(tooltip ? ' title="' + tooltip + '"' : '') +
-			' href="' + href + '"' +
-			(target ? ' target="' + target + '"' : '') +
-			'>' + text + '</a>';
-	}
-
-	class Link {
-
-		toSymbol(longname) {
-			if ( longname != null ) {
-				longname = String(longname);
-				if ( /#constructor$/.test(longname) ) {
-					if ( !this.innerName ) {
-						this.innerName = 'constructor';
-					}
-					longname = longname.slice(0, -"#constructor".length);
-				}
-				this.longname = longname;
-			}
-			return this;
-		}
-
-		withText(text) {
-			this.text = text;
-			return this;
-		}
-
-		withTooltip(text) {
-			this.tooltip = text;
-			return this;
-		}
-
-		toFile(file) {
-			if ( file != null ) {
-				this.file = file;
-			}
-			return this;
-		}
-
-		toString() {
-			let longname = this.longname;
-
-			if (longname) {
-
-				if ( /^(?:(?:ftp|https?):\/\/|\.\.?\/)/.test(longname) ) {
-					// handle real hyperlinks (TODO should be handled with a different "to" method
-					return _makeLink(longname, this.targetName, this.tooltip, this.text || longname);
-				} else if ( /^topic:/.test(longname) ) {
-					// handle documentation links
-					longname = conf.topicUrlPattern.replace("{{topic}}", longname.slice("topic:".length));
-					return _makeLink(longname, this.targetName, this.tooltip, this.text || longname);
-				} else {
-					return this._makeSymbolLink(longname);
-				}
-
-			} else if (this.file) {
-				return _makeLink(Link.base + this.file, this.targetName, null, this.text || this.file);
-			}
-
-			return undefined;
-		}
-
-		_makeSymbolLink(longname) {
-
-			// normalize .prototype. and #
-			longname = longname.replace(/\.prototype\./g, '#');
-
-			// if it is an internal reference, then don't validate against symbols, just create a link
-			if ( longname.charAt(0) == "#" ) {
-
-				return _makeLink(longname + (this.innerName ? "#" + this.innerName : ""), this.targetName, this.tooltip, this.text || longname.slice(1));
-
-			}
-
-			let linkTo = lookup(longname);
-			// if there is no symbol by that name just return the name unaltered
-			if ( !linkTo ) {
-
-				missingTypes[longname] = true;
-
-				return this.text || longname;
-
-			}
-
-			// it's a full symbol reference (potentially to another file)
-			let mainSymbol, anchor;
-			if ( (linkTo.kind === 'member' && !linkTo.isEnum) || linkTo.kind === 'constant' || linkTo.kind === 'function' || linkTo.kind === 'event' ) { // it's a method or property
-
-				mainSymbol = linkTo.memberof;
-				anchor = ( linkTo.kind === 'event' ? "event:" : "") + Link.symbolNameToLinkName(linkTo);
-
-			} else {
-
-				mainSymbol = linkTo.longname;
-				anchor = this.innerName;
-
-			}
-
-			return _makeLink(Link.baseSymbols + __uniqueFilenames[mainSymbol] + conf.ext + (anchor ? "#" + anchor : ""), this.targetName, this.tooltip, this.text || longname);
-		}
-
-	}
-
-	Link.getMissingTypes = function() {
-		return Object.keys(missingTypes);
-	};
-
-	Link.symbolNameToLinkName = function(symbol) {
-		let linker = "";
-		if ( symbol.scope === 'static' ) {
-			linker = ".";
-		} else if (symbol.isInner) {
-			linker = "-"; // TODO-migrate?
-		}
-		return linker + symbol.name;
-	};
-
-	return Link;
-
-}());
-
-
-
-// ---- publish() - main entry point for JSDoc templates -------------------------------------------------------------------------------------------------------
-
-/* Called automatically by JsDoc Toolkit. */
-function publish(symbolSet) {
-
-	info("entering sapui5 template");
-
-	// create output dir
-	fs.mkPath(env.opts.destination);
-
-	__symbols = symbolSet().get();
-
-//	if ( __symbols.length < 20000 ) {
-//		const rawSymbolsFile = path.join(env.opts.destination, "symbols-unpruned-ui5.json");
-//		info(`writing raw symbols to ${rawSymbolsFile}`);
-//		fs.writeFileSync(rawSymbolsFile, JSON.stringify(__symbols, filter, "\t"), 'utf8');
-//	}
-
-	info(`before prune: ${__symbols.length} symbols.`);
-	symbolSet = helper.prune(symbolSet);
-	__symbols = symbolSet().get();
-	info(`after prune: ${__symbols.length} symbols.`);
-
-	__longnames = {};
-	__symbols.forEach(function($) {
-		__longnames[$.longname] = $;
-	});
-
-	if ( templateConf.apiJsonFolder ) {
-		info(`loading external apis from folder '${templateConf.apiJsonFolder}'`);
-		loadExternalSymbols(templateConf.apiJsonFolder);
-	}
-
-	const templatePath = path.join(env.opts.template, 'tmpl/');
-	info(`using templates from '${templatePath}'`);
-	view = new template.Template(templatePath);
-
+function writeSymbols(symbols, filename, caption) {
 	function filter(key,value) {
 		if ( key === 'meta' ) {
 			//return;
@@ -463,24 +223,48 @@ function publish(symbolSet) {
 		}
 		return value;
 	}
+	if ( symbols.length < 20000 ) {
+		const symbolsFile = path.join(env.opts.destination, filename);
+		info(`writing ${caption} to ${symbolsFile}`);
+		fs.writeFileSync(symbolsFile, JSON.stringify(symbols, filter, "\t"), 'utf8');
+	}
+}
+// ---- publish() - main entry point for JSDoc templates -------------------------------------------------------------------------------------------------------
 
-	// now resolve relationships
-	const aRootNamespaces = createNamespaceTree();
-	const hierarchyRoots = createInheritanceTree();
-	collectMembers();
-	mergeEventDocumentation();
+/* Called automatically by JsDoc Toolkit. */
+function publish(symbolSet) {
 
-	if ( __symbols.length < 20000 ) {
-		const rawSymbolsFile = path.join(env.opts.destination, "symbols-pruned-ui5.json");
-		info(`writing raw symbols to ${rawSymbolsFile}`);
-		fs.writeFileSync(rawSymbolsFile, JSON.stringify(__symbols, filter, "\t"), 'utf8');
-	}
+	info("entering sapui5 template");
+
+	// create output dir
+	fs.mkPath(env.opts.destination);
 
-	// used to allow Link to check the details of things being linked to
-	Link.symbolSet = symbolSet;
+	const originalSymbols = symbolSet().get();
+	// writeSymbols(originalSymbols, "symbols-unpruned-ui5.json", "raw symbols before prune");
 
+	info(`before prune: ${originalSymbols.length} symbols.`);
+	symbolSet = helper.prune(symbolSet);
 	// get an array version of the symbol set, useful for filtering
-	const symbols = __symbols;
+	const allSymbols = __symbols = symbolSet().get();
+	info(`after prune: ${allSymbols.length} symbols.`);
+
+	__longnames = {};
+	allSymbols.forEach(function($) {
+		__longnames[$.longname] = $;
+	});
+
+	if ( templateConf.apiJsonFolder ) {
+		info(`loading external apis from folder '${templateConf.apiJsonFolder}'`);
+		loadExternalSymbols(templateConf.apiJsonFolder);
+	}
+
+	// now resolve relationships
+	const aRootNamespaces = createNamespaceTree(allSymbols);
+	createInheritanceTree(allSymbols);
+	collectMembers(allSymbols);
+	mergeEventDocumentation(allSymbols);
+
+	writeSymbols(allSymbols, "symbols-pruned-ui5.json", "raw symbols after prune");
 
 	// -----
 
@@ -491,7 +275,7 @@ function publish(symbolSet) {
 				apiXmlFile: path.join(env.opts.destination, "jsapi.xml")
 			},
 			processor : function(conf) {
-				createAPIXML(symbols, conf.apiXmlFile, {
+				createAPIXML(allSymbols, conf.apiXmlFile, {
 					legacyContent: true
 				});
 			}
@@ -502,7 +286,7 @@ function publish(symbolSet) {
 				apiJsonFile: path.join(env.opts.destination, "api.json")
 			},
 			processor : function(conf) {
-				createAPIJSON(symbols, conf.apiJsonFile);
+				createAPIJSON(allSymbols, conf.apiJsonFile);
 			}
 		},
 
@@ -511,88 +295,16 @@ function publish(symbolSet) {
 				fullXmlFile: path.join(env.opts.destination, "fulljsapi.xml")
 			},
 			processor : function(conf) {
-				createAPIXML(symbols, conf.fullXmlFile, {
+				createAPIXML(allSymbols, conf.fullXmlFile, {
 					roots: aRootNamespaces,
 					omitDefaults : conf.omitDefaultsInFullXml,
 					resolveInheritance: true
 				});
 			}
-		},
-
-		"apijs" : {
-			defaults: {
-				jsapiFile: path.join(env.opts.destination, "api.js")
-			},
-			processor: function(conf) {
-				createAPIJS(symbols, conf.jsapiFile);
-			}
-		},
-
-		"full" : {
-			defaults : {
-				outdir: path.join(env.opts.destination, "full/"),
-				contentOnly: false,
-				hierarchyIndex: true
-			},
-			processor: function() {
-				publishClasses(symbolSet, aRootNamespaces, hierarchyRoots);
-			}
-		},
-
-		"public" : {
-			defaults: {
-				outdir: path.join(env.opts.destination, "public/"),
-				filter: function($) { return $.access === 'public' || $.access === 'protected' || $.access == null; },
-				contentOnly: false,
-				hierarchyIndex: true
-			},
-			processor: function(conf) {
-				publishClasses(symbolSet, aRootNamespaces, hierarchyRoots);
-			}
-		},
-
-		"demokit" : {
-			defaults: {
-				outdir: path.join(env.opts.destination, "demokit/"),
-				filter: function($) { return $.access === 'public' || $.access === 'protected' || $.access == null; },
-				contentOnly: true,
-				modulePages: true,
-				hierarchyIndex: false,
-				securityIndex: true,
-				sinceIndex: true,
-				deprecationIndex: true,
-				experimentalIndex: true,
-				suppressAuthor: true,
-				suppressVersion: true
-			},
-			processor: function(conf) {
-				publishClasses(symbolSet, aRootNamespaces, hierarchyRoots);
-			}
-		},
-
-		"demokit-internal" : {
-			defaults: {
-				outdir: path.join(env.opts.destination, "demokit-internal/"),
-				// filter: function($) { return $.access === 'public' || $.access === 'protected' || $.access === 'restricted' || $.access == null; },
-				contentOnly: true,
-				modulePages: true,
-				hierarchyIndex: false,
-				securityIndex: true,
-				sinceIndex: true,
-				deprecationIndex: true,
-				experimentalIndex: true,
-				suppressAuthor: true,
-				suppressVersion: true
-			},
-			processor: function(conf) {
-				publishClasses(symbolSet, aRootNamespaces, hierarchyRoots);
-			}
 		}
 
 	};
 
-	const now = new Date();
-
 	info("start publishing");
 	if ( Array.isArray(templateConf.variants) ) {
 		templateConf.variants.forEach((vVariant) => {
@@ -615,14 +327,7 @@ function publish(symbolSet) {
 				// Note: trailing slash expected for dirs
 				conf = merge({
 					ext: ".html",
-					filter: function($) { return true; },
-					templatesDir: "/templates/sapui5/",
-					symbolsDir: "symbols/",
-					modulesDir: "modules/",
-					topicUrlPattern: "../../guide/{{topic}}.html",
-					srcDir: "symbols/src/",
-					creationDate : now.getFullYear() + "-" + (now.getMonth() + 1) + "-" + now.getDay() + " " + now.getHours() + ":" + now.getMinutes(),
-					outdir: env.opts.destination
+					filter: function($) { return true; }
 				}, PUBLISHING_VARIANTS[vVariant.variant].defaults, templateConf, vVariant);
 
 				info(`publishing as variant '${vVariant.variant}'`);
@@ -641,31 +346,26 @@ function publish(symbolSet) {
 		});
 	}
 
-	let builtinSymbols = templateConf.builtinSymbols;
-	if ( builtinSymbols ) {
-		Link.getMissingTypes().filter(($) => builtinSymbols.indexOf($) < 0).sort().forEach(($) => {
-			// TODO instead of filtering topic: and fiori: links out here, they should be correctly linked in the template
-			if ( !/\{@link (?:topic:|fiori:)/.test($) ) {
-				warning(`unresolved reference: ${$}`);
-			}
-		});
-	}
 	info("publishing done.");
-
 }
 
 //---- namespace tree --------------------------------------------------------------------------------
 
-/*
- * Completes the tree of namespaces. Namespaces for which content is available
- * but which have not been documented are created as dummy without documentation.
+/**
+ * Completes the tree of namespaces.
+ *
+ * Namespaces for which content is available but which have not been documented
+ * are created as dummy, public namespace with empty documentation.
+ *
+ * @param {Array<doclet.Doclet>} allSymbols Array of all symbols to be published
+ * @returns {Array<doclet.Doclet>} Array of all root namespaces
  */
-function createNamespaceTree() {
+function createNamespaceTree(allSymbols) {
 
-	info(`create namespace tree (${__symbols.length} symbols)`);
+	info(`create namespace tree (${allSymbols.length} symbols)`);
 
 	const aRootNamespaces = [];
-	const aTypes = __symbols.filter((symbol) => isFirstClassSymbol(symbol));
+	const aTypes = allSymbols.filter((symbol) => isFirstClassSymbol(symbol));
 
 	for (let i = 0; i < aTypes.length; i++) { // loop with a for-loop as it can handle concurrent modifications
 
@@ -676,8 +376,6 @@ function createNamespaceTree() {
 			if ( !parent ) {
 				warning(`create missing namespace '${symbol.memberof}' (referenced by ${symbol.longname})`);
 				parent = makeNamespace(symbol.memberof);
-				__longnames[symbol.memberof] = parent;
-				__symbols.push(parent);
 				aTypes.push(parent); // concurrent modification: parent will be processed later in this loop
 			}
 			symbol.__ui5.parent = parent;
@@ -698,17 +396,11 @@ function makeNamespace(memberof) {
 
 	info(`adding synthetic namespace symbol ${memberof}`);
 
-	const comment = [
-		"@name " + memberof,
+	return createSymbol(memberof, [
 		"@namespace",
 		"@synthetic",
 		"@public"
-	];
-
-	const symbol = new doclet.Doclet("/**\n * " + comment.join("\n * ") + "\n */", {});
-	symbol.__ui5 = {};
-
-	return symbol;
+	]);
 }
 
 //---- inheritance hierarchy ----------------------------------------------------------------------------
@@ -724,26 +416,19 @@ function makeNamespace(memberof) {
  *      derived   : {Node[]}     // subclasses/-types
  * }
  *
+ * @param {Array<doclet.Doclet>} allSymbols Array of all symbols to be published
+ * @returns {Array<doclet.Doclet>} Array of all root types
  */
-function createInheritanceTree() {
-
-	function makeDoclet(longname, lines) {
-		lines.push("@name " + longname);
-		const newDoclet = new doclet.Doclet("/**\n * " + lines.join("\n * ") + "\n */", {});
-		newDoclet.__ui5 = {};
-		__longnames[longname] = newDoclet;
-		__symbols.push(newDoclet);
-		return newDoclet;
-	}
+function createInheritanceTree(allSymbols) {
 
-	info(`create inheritance tree (${__symbols.length} symbols)`);
+	info(`create inheritance tree (${allSymbols.length} symbols)`);
 
-	const aTypes = __symbols.filter((symbol) => supportsInheritance(symbol));
+	const aTypes = allSymbols.filter((symbol) => supportsInheritance(symbol));
 	const aRootTypes = [];
 
 	let oObject = lookup("Object");
 	if ( !oObject ) {
-		oObject = makeDoclet("Object", [
+		oObject = createSymbol("Object", [
 			"@class",
 			"@synthetic",
 			"@public"
@@ -766,7 +451,7 @@ function createInheritanceTree() {
 				warning(`create missing class ${sClass} (extended by ${sExtendingClass})`);
 			}
 			let oBaseClass = getOrCreateClass(sBaseClass, sClass);
-			oClass = makeDoclet(sClass, [
+			oClass = createSymbol(sClass, [
 				"@extends " + sBaseClass,
 				"@" + sKind,
 				"@synthetic",
@@ -812,7 +497,7 @@ function createInheritanceTree() {
 					}  else {
 						warning(`create missing interface ${oClass.implements[j]}`);
 					}
-					oInterface = makeDoclet(oClass.implements[j], [
+					oInterface = createSymbol(oClass.implements[j], [
 						"@interface",
 						"@synthetic",
 						sVisibility === "restricted" ? "@ui5-restricted" : "@" + sVisibility
@@ -868,8 +553,13 @@ function createInheritanceTree() {
 	return aRootTypes;
 }
 
-function collectMembers() {
-	__symbols.forEach(function($) {
+/**
+ * Attaches each symbol to its parent ('memberof').
+ *
+ * @param {Array<doclet.Doclet>} allSymbols Array of all symbols to be published
+ */
+function collectMembers(allSymbols) {
+	allSymbols.forEach(function($) {
 		if ( $.memberof ) {
 			const parent = lookup($.memberof);
 			if ( parent /* && supportsInheritance(parent) */ ) {
@@ -880,11 +570,17 @@ function collectMembers() {
 	});
 }
 
-function mergeEventDocumentation() {
+/**
+ * Searches for JSDoc events that are also described in UI5 metadata
+ * and merges the parameter description from the JSDoc event into the UI5 event.
+ *
+ * @param {Array<doclet.Doclet>} allSymbols Array of all symbols to be published
+ */
+function mergeEventDocumentation(allSymbols) {
 
 	debug("merging JSDoc event documentation into UI5 metadata");
 
-	const aTypes = __symbols.filter((symbol) => isaClass(symbol));
+	const aTypes = allSymbols.filter((symbol) => isaClass(symbol));
 
 	aTypes.forEach((symbol) => {
 
@@ -935,181 +631,6 @@ function mergeEventDocumentation() {
 
 // ---- publishing -----------------------------------------------------------------------
 
-function publishClasses(symbols, aRootNamespaces, hierarchyRoots) {
-
-	// create output dir
-	fs.mkPath(path.join(conf.outdir, conf.symbolsDir));
-
-	// get a list of all the first class symbols in the symbolset
-	const firstClassSymbols = symbols(function() {
-		return supportsInheritance(this) && conf.filter(this);
-	}).order("longname");
-
-	// create unique file names
-	__uniqueFilenames = {};
-	let filenames = {};
-	firstClassSymbols.get().sort(sortByAlias).forEach(function(symbol) {
-		const filename = escape(symbol.longname.replace(/^module:/, "")).replace(/\//g, "%25");
-		if ( filenames.hasOwnProperty(filename.toUpperCase()) && (filenames[filename.toUpperCase()].longname !== symbol.longname) ) {
-			// find an unused filename by appending "-n" where n is an integer > 0
-			let j = 1;
-			while (filenames.hasOwnProperty(filename.toUpperCase() + "-" + j)) {
-				j++;
-			}
-			warning(`duplicate symbol names ${filenames[filename.toUpperCase()].longname} and ${symbol.longname}, renaming the latter to ${filename + "-" + j}`);
-			filename = filename + "-" + j;
-		}
-		filenames[filename.toUpperCase()] = symbol;
-		__uniqueFilenames[symbol.longname] = filename;
-	});
-	filenames = null;
-
-	// create a class index, displayed in the left-hand column of every class page
-	let classTemplate;
-	if ( !conf.contentOnly ) {
-		info("create embedded class index");
-		Link.base = "../";
-		Link.baseSymbols = "";
-		classTemplate = 'classWithIndex.html.tmpl';
-		publish.header = processTemplate("_header.tmpl", firstClassSymbols);
-		publish.footer = processTemplate("_footer.tmpl", firstClassSymbols);
-		publish.classesIndex = processTemplate("_navIndex.tmpl", firstClassSymbols); // kept in memory
-	} else {
-		let newStyle = !!pluginConf.newStyle;
-		classTemplate = newStyle ? "class-new.html.tmpl" : "class.html.tmpl";
-		publish.header = '';
-		publish.footer = '';
-		publish.classesIndex = '';
-
-		// instead create an index as XML
-		Link.base = "";
-		Link.baseSymbols = conf.symbolsDir;
-		processTemplateAndSave("index.xml.tmpl", aRootNamespaces, "index.xml");
-	}
-
-	// create each of the class pages
-	info("create class/namespace pages");
-	Link.base = "../";
-	Link.baseSymbols = "";
-	firstClassSymbols.each(function(symbol) {
-		let sOutName = path.join(conf.symbolsDir, __uniqueFilenames[symbol.longname]) + conf.ext;
-		processTemplateAndSave(classTemplate, symbol, sOutName);
-	});
-
-	if ( conf.modulePages ) {
-		info("create module pages");
-		Link.base = "../";
-		Link.baseSymbols = "../" + conf.symbolsDir;
-		fs.mkPath(path.join(conf.outdir, conf.modulesDir));
-		groupByModule(firstClassSymbols.get()).forEach(function(module) {
-			let sOutName = path.join(conf.modulesDir, module.name.replace(/\//g, '_')) + conf.ext;
-			processTemplateAndSave("module.html.tmpl", module, sOutName);
-		});
-	}
-
-	// regenerate the index with a different link base, used in the overview pages
-	info("create global class/namespace index");
-	Link.base = "";
-	Link.baseSymbols = conf.symbolsDir;
-	publish.header = processTemplate("_header.tmpl", firstClassSymbols);
-	publish.footer = processTemplate("_footer.tmpl", firstClassSymbols);
-	publish.classesIndex = processTemplate("_navIndex.tmpl", firstClassSymbols);
-
-	// create the all classes index
-	processTemplateAndSave("index.html.tmpl", firstClassSymbols, "index" + conf.ext);
-
-	// create the class hierarchy page
-	if ( conf.hierarchyIndex ) {
-		info("create class hierarchy index");
-		Link.base = "";
-		Link.baseSymbols = conf.symbolsDir;
-		processTemplateAndSave("hierarchy.html.tmpl", hierarchyRoots.filter(conf.filter), "hierarchy" + conf.ext);
-	}
-
-	if ( conf.sinceIndex ) {
-		info("create API by version index");
-		Link.base = "";
-		Link.baseSymbols = conf.symbolsDir;
-		let sinceSymbols = symbols(function() {
-			let r = !!this.since && !this.inherited && conf.filter(this);
-			if ( r && this.memberof ) {
-				let parent = lookup(this.memberof);
-				// filter out symbol when parent is filtered out
-				if ( !parent || !conf.filter(parent) ) {
-					debug(`since index: filtering out ${this.longname}, member of ${this.memberof}`);
-					r = false;
-				}
-				if ( parent && parent.since === this.since ) {
-					// r = false;
-				}
-			}
-			return r;
-		}).order("longname");
-		processTemplateAndSave("since.html.tmpl", sinceSymbols, "since" + conf.ext);
-	}
-
-	if ( conf.deprecationIndex ) {
-		info("create deprecated API index");
-		Link.base = "";
-		Link.baseSymbols = conf.symbolsDir;
-		let deprecatedSymbols = symbols(function() {
-			return !!this.deprecated && !this.inherited && conf.filter(this);
-		}).order("longname");
-		processTemplateAndSave("deprecation.html.tmpl", deprecatedSymbols, "deprecation" + conf.ext);
-	}
-
-	if ( conf.experimentalIndex ) {
-		info("create experimental API index");
-		Link.base = "";
-		Link.baseSymbols = conf.symbolsDir;
-		let experimentalSymbols = symbols(function() {
-			return !!this.experimental && !this.inherited && conf.filter(this);
-		}).order("longname");
-		processTemplateAndSave("experimental.html.tmpl", experimentalSymbols, "experimental" + conf.ext);
-	}
-
-	if ( conf.securityIndex ) {
-		info("create Security Relevant API index");
-
-		let securityRelevantSymbols = {};
-		A_SECURITY_TAGS.forEach(function(oTagDef) {
-			securityRelevantSymbols[oTagDef.name.toLowerCase()] = { tag : oTagDef, symbols: [] };
-		});
-		symbols().each(function($) {
-			let tags = $.tags;
-			if ( !$.inherited  && conf.filter($) && tags ) {
-				for (let i = 0; i < tags.length; i++) {
-					if ( rSecurityTags.test(tags[i].title) ) {
-						securityRelevantSymbols[tags[i].title.toLowerCase()].symbols.push({ symbol: $, tag : tags[i]});
-					}
-				}
-			}
-		});
-
-		Link.base = "";
-		Link.baseSymbols = conf.symbolsDir;
-		processTemplateAndSave("security.html.tmpl", securityRelevantSymbols, "security" + conf.ext);
-	}
-
-	firstClassSymbols = null;
-
-	// copy needed mimes
-	info("copy mimes");
-	// copy the template's static files to outdir
-	let templatePath = env.opts.template;
-	let fromDir = path.join(templatePath, 'static');
-	let staticFiles = fs.ls(fromDir, 3);
-	staticFiles.forEach(function(fileName) {
-		let toDir = fs.toDir( fileName.replace(fromDir, conf.outdir) );
-		fs.mkPath(toDir);
-		fs.copyFileSync(fileName, toDir);
-	});
-
-	__uniqueFilenames = null;
-
-	info("publishing done.");
-}
-
 // ---- helper functions for the templates ----
 
 function sortByAlias(a, b) {
@@ -1142,27 +663,6 @@ function sortByAlias(a, b) {
 	return 0;
 }
 
-/*
-function isNonEmptyNamespace($) {
-	return $.isNamespace && (
-			($.properties && $.properties.length > 0) ||
-			($.methods && $.methods.length > 0) ||
-			($.augments && $.augments.length > 0) ||
-			($.children && $.children.length > 0));
-};*/
-
-/* Just the first sentence (up to a full stop). Should not break on dotted variable names. */
-function summarize(desc) {
-	if ( desc != null ) {
-		desc = String(desc).replace(/\s+/g, ' ').
-					replace(/"'/g, '&quot;').
-					replace(/^(<\/?p>|<br\/?>|\s)+/, '');
-
-		const match = /([\w\W]+?\.)[^a-z0-9_$]/i.exec(desc);
-		return match ? match[1] : desc;
-	}
-}
-
 /* Make a symbol sorter by some attribute. */
 function makeSortby(/* fields ...*/) {
 	const aFields = Array.prototype.slice.apply(arguments),
@@ -1215,339 +715,8 @@ function makeSortby(/* fields ...*/) {
 	};
 }
 
-/** Pull in the contents of an external file at the given path. */
-
-function processTemplateAndSave(sTemplateName, oData, sOutputName) {
-	let sResult = processTemplate(sTemplateName, oData);
-	if ( conf.normalizeWhitespace && /\.html$/.test(sOutputName) ) {
-		sResult = normalizeWhitespace(sResult);
-	}
-	const sOutpath = path.join(conf.outdir, sOutputName);
-	try {
-		fs.mkPath( path.dirname(sOutpath) );
-		fs.writeFileSync(sOutpath, sResult, 'utf8');
-	} catch (e) {
-		error(`failed to write generated file '${sOutpath}': ${e.message || e}`);
-	}
-}
-
-function processTemplate(sTemplateName, data) {
-	debug(`processing template '${sTemplateName}' for ${data.longname}`);
-
-	let result;
-
-	try {
-		result = view.render(sTemplateName, {
-			asPlainSummary: asPlainSummary,
-			bySimpleName: bySimpleName,
-			childrenOfKind: childrenOfKind,
-			conf: conf,
-			data: data,
-			getConstructorDescription : getConstructorDescription,
-			getNSClass: getNSClass,
-			groupByVersion: groupByVersion,
-			extractSince: extractSince,
-			include: processTemplate,
-			Link: Link,
-			listTypes: listTypes,
-			linkTypes: linkTypes,
-			makeExample: makeExample,
-			makeLinkList: makeLinkList,
-			makeLinkToSymbolFile: makeLinkToSymbolFile,
-			makeSignature: makeSignature,
-			makeSortby: makeSortby,
-			publish : publish,
-			formatText: formatText,
-			simpleNameOf: simpleNameOf,
-			sortByAlias: sortByAlias,
-			summarize: summarize,
-			Version : Version
-		});
-	} catch (e) {
-		if ( e.source ) {
-			const filename = path.join(env.opts.destination, sTemplateName + ".js");
-			error(`failed to process template, source written to ${filename}`);
-			fs.mkPath(path.dirname(filename));
-			fs.writeFileSync(filename, e.source, 'utf8');
-		}
-		error(`error while processing ${sTemplateName}`);
-		throw e;
-	}
-	debug("processing template done.");
-	return result;
-}
-
-function groupByVersion(symbols, extractVersion) {
-
-	const map = {};
-
-	symbols.forEach((symbol) => {
-
-		const version = extractVersion(symbol),
-			key = String(version);
-
-		if ( !map[key] ) {
-			map[key] = {
-				version,
-				symbols : []
-			};
-		}
-		map[key].symbols.push(symbol);
-
-	});
-
-	const groups = Object.values(map);
-
-	return groups.sort((a,b) => {
-		if ( !a.version && b.version ) {
-			return -1;
-		} else if ( a.version && !b.version ) {
-			return 1;
-		} else if ( a.version && b.version ) {
-			return -a.version.compareTo(b.version);
-		}
-		return 0;
-	});
-}
-
-function groupByModule(symbols) {
-
-	const map = {};
-
-	function add(key, symbol) {
-		if ( !map[key] ) {
-			map[key] = {
-				name: key,
-				symbols : []
-			};
-		}
-		if ( map[key].symbols.indexOf(symbol) < 0 ) {
-			map[key].symbols.push(symbol);
-		}
-	}
-
-	symbols.forEach((symbol) => {
-
-		const key = symbol.__ui5.module;
-
-		if ( key ) {
-			add(key, symbol);
-			if ( symbol.__ui5.members ) {
-				symbol.__ui5.members.forEach(function($) {
-					if ( !$.inherited && $.__ui5.module && $.__ui5.module !== key && conf.filter($) ) {
-						add($.__ui5.module, $);
-					}
-				});
-			}
-		}
-
-	});
-
-	return Object.values(map);
-}
-
-
-const REGEXP_TAG = /<(\/?(?:[A-Z][A-Z0-9_-]*:)?[A-Z][A-Z0-9_-]*)(?:\s[^>]*)?>/gi;
-
-/**
- * Removes unnecessary whitespace from an HTML document:
- *  - if the text between two adjacent HTML tags consists of whitespace only, the whole text is removed
- *  - otherwise, any sequence of whitespace in the text is reduced to a single blank
- *  - inside a <pre> tag, whitespace is preserved
- *
- * Whitespace inside an element tag is not touched (although it could be normalized as well)
- * @param {string} content raw HTML file
- * @returns {string} HTML file with normalized whitespace
- */
-function normalizeWhitespace(content) {
-	let compressed = '',
-		preformatted = 0,
-		p = 0, m;
-
-	REGEXP_TAG.lastIndex = 0;
-	while ( (m = REGEXP_TAG.exec(content)) ) {
-		if ( m.index > p ) {
-			let text = content.slice(p, m.index);
-			if ( preformatted ) {
-				compressed += text;
-				// debug(`  '${text}' (preformatted)`);
-			} else {
-				text = text.replace(/\s+/g,' ');
-				if ( text.trim() ) {
-					compressed += text;
-				}
-				// debug(`  '${text}' (trimmed)`);
-			}
-		}
-
-		compressed += m[0];
-		// debug(`  '${m[0]}' (tag)`);
-		p = m.index + m[0].length;
-
-		if ( /^pre$/i.test(m[1]) ) {
-			preformatted++;
-		} else if ( /^\/pre$/i.test(m[1]) && preformatted ) {
-			preformatted--;
-		}
-
-	}
-
-	if ( content.length > p ) {
-		let text = content.slice(p, content.length);
-		if ( preformatted ) {
-			compressed += text;
-			// debug(`  '${text}' (preformatted)`);
-		} else {
-			text = text.replace(/\s+/g,' ');
-			if ( text.trim() ) {
-				compressed += text;
-			}
-			// debug(`  '${text}' (trimmed)`);
-		}
-	}
-
-	return compressed;
-}
-
-function makeLinkToSymbolFile(longname) {
-	return Link.baseSymbols + __uniqueFilenames[longname] + conf.ext;
-}
-
-function simpleNameOf(longname) {
-	longname = String(longname);
-	const p = longname.lastIndexOf('.');
-	return p < 0 ? longname : longname.slice(p + 1);
-}
-
-function bySimpleName(a,b) {
-	if ( a === b ) {
-		return 0;
-	}
-	const simpleA = simpleNameOf(a);
-	const simpleB = simpleNameOf(b);
-	if ( simpleA === simpleB ) {
-		return a < b ? -1 : 1;
-	} else {
-		return simpleA < simpleB ? -1 : 1;
-	}
-}
-
-/* Build output for displaying function parameters. */
-function makeSignature(params) {
-	const r = ['('];
-	if ( params ) {
-		for (let i = 0, p; (p = params[i]); i++) {
-			// ignore @param tags for 'virtual' params that are used to document members of config-like params
-			// (e.g. like "@param param1.key ...")
-			if (p.name && p.name.indexOf('.') == -1) {
-				if (i > 0) {
-					r.push(', ');
-				}
-
-				r.push('<span');
-
-				const types = listTypes(p.type, true);
-				const desc = asPlainSummary(p.description);
-				if ( desc || types ) {
-					r.push(' title="');
-					if (types) {
-						r.push('(');
-						r.push(types);
-						r.push(') ');
-					}
-					r.push(desc);
-					r.push('"');
-				}
-
-				r.push('>');
-				r.push(p.name);
-				r.push('</span>');
-				if ( p.optional ) {
-					r.push('<i class="help" title="Optional parameter">?</i>');
-				}
-			}
-		}
-	}
-	r.push(')');
-	return r.join('');
-}
-
-
-/*
- * regexp to recognize important places in the text
- *
- * Capturing groups of the RegExp:
- *   group 1: begin of a pre block
- *   group 2: end of a pre block
- *   group 3: begin of a header/ul/ol/table, implicitly ends a paragraph
- *   group 4: end of a header/ul/ol/table, implicitly starts a new paragraph
- *   group 5: target portion of an inline @link tag
- *   group 6: (optional) text portion of an inline link tag
- *   group 7: an empty line which implicitly starts a new paragraph
- *
- *                   [------- <pre> block -------] [----------------------- some flow content -----------------------] [---- an inline {@link ...} tag ----] [---------- an empty line ---------]  */
-const rFormatText = /(<pre(?:\s[^>]*)?>)|(<\/pre>)|(<(?:h[\d+]|ul|ol|table)(?:\s[^>]*)?>)|(<\/(?:h[\d+]|ul|ol|table)>)|\{@link\s+([^}\s]+)(?:\s+([^\}]*))?\}|((?:\r\n|\r|\n)[ \t]*(?:\r\n|\r|\n))/gi;
-
-function formatText(text) {
-
-	if ( !text ) {
-		return '';
-	}
-
-	let inpre = false,
-		paragraphs = 0;
-
-	text = String(text).replace(rFormatText, function(match, pre, endpre, flow, endflow, linkTarget, linkText, emptyline) {
-		if ( pre ) {
-			inpre = true;
-			return pre.replace(/<pre>/gi, "<pre class=\"prettyprint\">").replace(/<pre\s+lang="([^"]+)"\s*>/gi, "<pre class=\"prettyprint lang-$1\">");
-		} else if ( endpre ) {
-			inpre = false;
-		} else if ( flow ) {
-			if ( !inpre ) {
-				paragraphs++;
-				return '</p>' + match;
-			}
-		} else if ( endflow ) {
-			if ( !inpre ) {
-				paragraphs++;
-				return match + '<p>';
-			}
-		} else if ( emptyline ) {
-			if ( !inpre ) {
-				paragraphs++;
-				return '</p><p>';
-			}
-		} else if ( linkTarget ) {
-			if ( !inpre ) {
-				// convert to a hyperlink
-				let link = new Link().toSymbol(linkTarget);
-				// if link tag contained a replacement text, use it
-				if ( linkText && linkText.trim()) {
-					link = link.withText(linkText.trim());
-				}
-				return link.toString();
-			}
-		}
-		return match;
-	});
-
-	if ( paragraphs > 0 ) {
-		text = '<p>' + text + '</p>';
-	}
-
-	// remove empty paragraphs
-	text = text.replace(/<p>\s*<\/p>/g, '');
-
-	return text;
-}
-
-
-function childrenOfKind(data, kind) {
-	let oResult = {
-		own: [],
-		borrowed: []
-	};
+function getMembersOfKind(data, kind) {
+	let oResult = [];
 	//debug(`calculating kind ${kind} from ${data.longname}`);
 	//console.log(data);
 	let fnFilter;
@@ -1575,86 +744,15 @@ function childrenOfKind(data, kind) {
 
 	if ( data.__ui5.members ) {
 		data.__ui5.members.forEach(function($) {
-			if ( fnFilter($) && conf.filter($) ) {
-				oResult[$.inherited ? 'borrowed' : 'own'].push($);
+			if ( !$.inherited && fnFilter($) && conf.filter($) ) {
+				oResult.push($);
 			}
 		});
 	}
-	oResult.own.sort(makeSortby("!deprecated","static","name"));
-	oResult.borrowed = groupByContributors(data, oResult.borrowed);
 
 	return oResult;
 }
 
-/**
- * Determines the set of contributors of the given borrowed members.
- * The contributors are sorted according to the inheritance hierarchy:
- * first the base class of symbol, then the base class of the base class etc.
- * Any contributors that can not be found in the hierarchy are appended
- * to the set.
- *
- * @param {Symbol} symbol of which these are the members
- * @param {array} aBorrowedMembers set of borrowed members to determine the contributors for
- * @return {array} sorted array of contributors
- */
-function groupByContributors(symbol, aBorrowedMembers) {
-
-	let MAX_ORDER = 1000, // a sufficiently large number
-		mContributors = {},
-		aSortedContributors = [];
-
-	aBorrowedMembers.forEach(function(borrowed) {
-		let $ = lookup(borrowed.inherits);
-		if ($) {
-			if (mContributors[$.memberof] == null) {
-				mContributors[$.memberof] = { order : MAX_ORDER, items : [$] };
-			} else {
-				mContributors[$.memberof].items.push($);
-			}
-		} else {
-			future(`symbol '${borrowed.longname}' has 'inherited' flag set, but inherits missing symbol '${borrowed.inherits}' (skipped)`);
-		}
-	});
-
-	// order contributors according to their distance in the inheritance hierarchy
-	let order = 0;
-	(function handleAugments(oSymbol) {
-		if ( oSymbol.augments ) {
-			const aParentsToVisit = [];
-			// first assign an order
-			for (let i = 0; i < oSymbol.augments.length; i++) {
-				if ( mContributors[oSymbol.augments[i]] != null && mContributors[oSymbol.augments[i]].order === MAX_ORDER ) {
-					mContributors[oSymbol.augments[i]].order = ++order;
-					aParentsToVisit.push(oSymbol.augments[i]);
-				}
-			}
-			// only then dive into parents (breadth first search)
-			for (let i = 0; i < aParentsToVisit.length; i++) {
-				const oTarget = lookup(aParentsToVisit);
-				if ( oTarget ) {
-					handleAugments(oTarget);
-				}
-			}
-		}
-	}(symbol));
-
-	// convert to an array and sort by order
-	for (let i in mContributors) {
-		aSortedContributors.push(mContributors[i]);
-	}
-	aSortedContributors.sort((a,b) => a.order - b.order);
-
-	return aSortedContributors;
-
-}
-
-function makeLinkList(aSymbols) {
-	return aSymbols
-		.sort(makeSortby("name"))
-		.map(($) => new Link().toSymbol($.longname).withText($.name))
-		.join(", ");
-}
-
 // ---- type parsing ---------------------------------------------------------------------------------------------
 
 class ASTBuilder {
@@ -1730,6 +828,7 @@ class ASTBuilder {
 	}
 	optional(type) {
 		type.optional = true;
+		return type;
 	}
 	repeatable(type) {
 		type.repeatable = true;
@@ -1809,10 +908,18 @@ class TypeStringBuilder {
 	structure(structure) {
 		const r = [];
 		for ( let fieldName in structure ) {
-			if ( structure[fieldName].synthetic ) {
+			const typeOfField = structure[fieldName];
+			// This builder is called bottom up. Therefore, an optional field
+			// has been encoded as a trailing "=" in typeOfField.str already.
+			// But for structures, the "=" must be added to the field name instead.
+			if ( typeOfField.str.endsWith("=") ) {
+				fieldName += "=";
+				typeOfField.str = typeOfField.str.slice(0, -1);
+			}
+			if ( typeOfField.synthetic ) {
 				r.push(fieldName);
 			} else {
-				r.push(fieldName + ":" + this.safe(structure[fieldName]));
+				r.push(fieldName + ":" + this.safe(typeOfField));
 			}
 		}
 		return {
@@ -1957,7 +1064,7 @@ function TypeParser(defaultBuilder = new ASTBuilder()) {
 				}
 				const optional = token === "=";
 				if ( optional ) {
-					builder.optional(paramType);
+					paramType = builder.optional(paramType);
 					next();
 				}
 				paramTypes.push(paramType);
@@ -1996,12 +1103,19 @@ function TypeParser(defaultBuilder = new ASTBuilder()) {
 				}
 				next("symbol");
 				let propType;
+				const optional = token === "=";
+				if ( optional ) {
+					next();
+				}
 				if ( token === ":" ) {
 					next();
 					propType = parseTypes();
 				} else {
 					propType = builder.synthetic(builder.simpleType("any"));
 				}
+				if ( optional ) {
+					propType = builder.optional(propType);
+				}
 				structure[propName] = propType;
 				if ( token === "}" ) {
 					break;
@@ -2084,32 +1198,8 @@ function TypeParser(defaultBuilder = new ASTBuilder()) {
 	};
 }
 
-class TypeLinkBuilder extends TypeStringBuilder {
-	constructor(style, encoded) {
-		super();
-		this.linkStyle = style;
-		this.lt = encoded ? "&lt;" : "<";
-		this.gt = encoded ? "&gt;" : ">";
-	}
-	simpleType(type) {
-		if ( this.linkStyle === 'text' ) {
-			return super.simpleType(type);
-		}
-		const link = new Link().toSymbol(type);
-		if ( this.linkStyle === 'short' ) {
-			link.withText(simpleNameOf(type)).withTooltip(type);
-		}
-		return {
-			str: link.toString()
-		};
-	}
-}
-
 const typeParser = new TypeParser();
 const _TEXT_BUILDER = new TypeStringBuilder();
-const _TEXT_BUILDER_ENCODED = new TypeLinkBuilder('text', true);
-const _SHORT_BUILDER = new TypeLinkBuilder('short', true);
-const _LONG_BUILDER = new TypeLinkBuilder('long', true);
 
 /*
 function testTypeParser(type) {
@@ -2143,12 +1233,8 @@ function _processTypeString(type, builder) {
 	}
 }
 
-function listTypes(type, encoded) {
-	return _processTypeString(type, encoded ? _TEXT_BUILDER_ENCODED : _TEXT_BUILDER);
-}
-
-function linkTypes(type, short) {
-	return _processTypeString(type, short ? _SHORT_BUILDER : _LONG_BUILDER );
+function listTypes(type) {
+	return _processTypeString(type, _TEXT_BUILDER);
 }
 
 function isArrayType(type) {
@@ -2166,31 +1252,6 @@ function isArrayType(type) {
 	return false;
 }
 
-/**
- * Reduces the given text to a summary and removes all tags links etc. and escapes double quotes.
- * The result therefore should be suitable as content for an HTML tag attribute (e.g. title).
- *
- * @param {string} sText Text to extract a summary from
- * @returns {string} summarized, plain attribute
- */
-function asPlainSummary(sText) {
-	return sText ? summarize(sText).replace(/<.*?>/g, '').replace(/\{\@link\s*(.*?)\}/g, '$1').replace(/"/g,"&quot;") : '';
-}
-
-function getNSClass(item) {
-	if (item.kind === 'interface') {
-		return " interface";
-	} else if (item.kind === 'namespace') {
-		return " namespace";
-	} else if (item.kind === 'typedef' ) {
-		return " typedef";
-	} else if (item.kind === 'member' && item.isEnum ) {
-		return " enum";
-	} else {
-		return "";
-	}
-}
-
 function normalizeLF(text) {
 	if ( text == null ) {
 		return text;
@@ -3126,7 +2187,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 	}
 
 	if ( !skipMembers ) {
-		const ownProperties = childrenOfKind(symbol, "property").own.sort(sortByAlias);
+		const ownProperties = getMembersOfKind(symbol, "property").sort(sortByAlias);
 		if ( ownProperties.length > 0 ) {
 			collection("properties");
 			for ( let i = 0; i < ownProperties.length; i++ ) {
@@ -3159,7 +2220,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 			endCollection("properties");
 		}
 
-		const ownEvents = childrenOfKind(symbol, 'event').own.sort(sortByAlias);
+		const ownEvents = getMembersOfKind(symbol, 'event').sort(sortByAlias);
 		if ( ownEvents.length > 0 ) {
 			collection("events");
 			for (let i = 0; i < ownEvents.length; i++ ) {
@@ -3209,7 +2270,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 			endCollection("events");
 		}
 
-		const ownMethods = childrenOfKind(symbol, 'method').own.sort(sortByAlias);
+		const ownMethods = getMembersOfKind(symbol, 'method').sort(sortByAlias);
 		// xmlmacro stereotype does not allow methods
 		if ( symbol.__ui5.stereotype !== 'xmlmacro' && ownMethods.length > 0 ) {
 			collection("methods");
@@ -3738,7 +2799,7 @@ function validateAPIJSON(api) {
 				}
 			});
 		}
-		if ( Object.prototype.hasOwnProperty.call(symbol, "constructor") ) {
+		if ( Object.hasOwn(symbol, "constructor") ) {
 			checkMethodSignature(symbol.constructor, symbol.name + ".constructor");
 		}
 		if ( symbol.properties ) {
@@ -3786,7 +2847,7 @@ function validateAPIJSON(api) {
 
 		Object.keys(missing).forEach((type) => {
 			if ( Array.isArray(missing[type]) ) {
-				if ( hasOwn(erroneousTypes, type.toLowerCase()) ) {
+				if ( Object.hasOwn(erroneousTypes, type.toLowerCase()) ) {
 					error(`type '${type}' (use '${erroneousTypes[type.toLowerCase()]}' instead)`);
 					missing[type].forEach((usage) => error(`  ${usage}`));
 				} else {
@@ -4628,223 +3689,6 @@ function createAPIXML(symbols, filename, options = {}) {
 	fs.writeFileSync(filename, getAsString(), 'utf8');
 }
 
-//---- add on: API JS -----------------------------------------------------------------
-
-function createAPIJS(symbols, filename) {
-
-	const REGEXP_ARRAY_TYPE = /^Array\.<(.*)>$/;
-
-	const rkeywords = /^(?:abstract|as|boolean|break|byte|case|catch|char|class|continue|const|debugger|default|delete|do|double|else|enum|export|extends|false|final|finally|float|for|function|goto|if|implements|import|in|instanceof|int|interface|is|long|namespace|native|new|null|package|private|protected|public|return|short|static|super|switch|synchronized|this|throw|throws|transient|true|try|typeof|use|var|void|volatile|while|with)$/;
-
-	const output = [];
-
-	function isNoKeyword($) { return !rkeywords.test($.name); }
-
-	function isAPI($) { return $.access === 'public' || $.access === 'protected' || !$.access; }
-
-	function writeln(args) {
-		if ( arguments.length ) {
-			for (let i = 0; i < arguments.length; i++) {
-				output.push(arguments[i]);
-			}
-		}
-		output.push("\n");
-	}
-
-	function unwrap(docletSrc) {
-		if (!docletSrc) {
-			return '';
-		}
-
-		// note: keep trailing whitespace for @examples
-		// extra opening/closing stars are ignored
-		// left margin is considered a star and a space
-		// use the /m flag on regex to avoid having to guess what this platform's newline is
-		docletSrc =
-			docletSrc.replace(/^\/\*\*+/, '') // remove opening slash+stars
-			.replace(/\**\*\/$/, "\\Z")       // replace closing star slash with end-marker
-			.replace(/^\s*(\* ?|\\Z)/gm, '')  // remove left margin like: spaces+star or spaces+end-marker
-			.replace(/\s*\\Z$/g, '');         // remove end-marker
-
-		return docletSrc;
-	}
-
-	function comment($, sMetaType) {
-
-		let s = unwrap($.comment.toString());
-
-		// remove the @desc tag
-		s = s.replace(/(\r\n|\r|\n)/gm, "\n");
-		s = s.replace(/^\s*@desc\s*/gm, "");
-		s = s.replace(/^\s*@alias[^\r\n]*(\r\n|\r|\n)?/gm, "");
-		s = s.replace(/^\s*@name[^\r\n]*(\r\n|\r|\n)?/gm, "");
-		s = s.replace(/^\s*@function[^\r\n]*(\r\n|\r|\n)?/gm, "");
-		s = s.replace(/^\s*@author[^\r\n]*(\r\n|\r|\n)?/gm, "");
-		s = s.replace(/^\s*@synthetic[^\r\n]*(\r\n|\r|\n)?/gm, "");
-		s = s.replace(/^\s*<\/p><p>\s*(\r\n|\r|\n)?/gm, "\n");
-		// skip empty documentation
-		if ( !s ) {
-			return;
-		}
-
-		// for namespaces, enforce the @.memberof tag
-		if ( sMetaType === "namespace" && $.memberof && s.indexOf("@memberof") < 0 ) {
-			s = s + "\n@memberof " + $.memberof;
-		}
-
-		writeln("/**\n * " + s.replace(/\n/g, "\n * ") + "\n */");
-
-		/*
-		writeln("/**");
-		writeln(s.split(/\r\n|\r|\n/g).map(function($) { return " * " + $;}).join("\r\n"));
-		writeln(" * /");
-		*/
-
-	}
-
-	function signature($) {
-		const p = $.params, r = [];
-		if ( p ) {
-			for (let i = 0; i < p.length; i++) {
-				// ignore @param tags for 'virtual' params that are used to document members of config-like params
-				// (e.g. like "@param param1.key ...")
-				if (p[i].name && p[i].name.indexOf('.') < 0) {
-					r.push(p[i].name);
-				}
-			}
-		}
-		return r.join(',');
-	}
-
-	function qname(member,parent) {
-		let r = member.memberof;
-		if ( member.scope !== 'static' ) {
-			r += ".prototype";
-		}
-		return (r ? r + "." : "") + member.name;
-	}
-
-	const mValues = {
-		"boolean"  : "false",
-		"int"      : "0",
-		"float"    : "0.0",
-		"number"   : "0.0",
-		"string"   : "\"\"",
-		"object"   : "new Object()",
-		"function" : "function() {}"
-	};
-
-	function valueForType(type) {
-		if ( type && type.names && type.names[0] ) {
-			type = type.names[0];
-			if ( REGEXP_ARRAY_TYPE.test(type) || type.indexOf("[]") > 0 ) {
-				return "new Array()";
-			} else if ( mValues[type] ) {
-				return mValues[type];
-			} else if ( type.indexOf(".") > 0 ) {
-				return "new " + type + "()";
-			} else {
-				// return "/* unsupported type: " +  member.type + " */ null";
-				return "null";
-			}
-		}
-	}
-
-	function value(member) {
-		return valueForType(member.type);
-	}
-
-	function retvalue(member) {
-		//debug(member);
-		const r = valueForType(member.type || (member.returns && member.returns.length && member.returns[0] && member.returns[0].type && member.returns[0].type));
-		if ( r ) {
-			return "return " + r + ";";
-		}
-		return "";
-	}
-
-	const sortedSymbols = symbols.slice().filter(($) => isaClass($) && isAPI($) && !$.synthetic).sort(sortByAlias); // sort only a copy(!) of the symbols, otherwise the SymbolSet lookup is broken
-	sortedSymbols.forEach((symbol) => {
-
-		const sMetaType = (symbol.kind === 'member' && symbol.isEnum) ? 'enum' : symbol.kind;
-		if ( sMetaType ) {
-
-			writeln("");
-			writeln("// ---- " + symbol.longname + " --------------------------------------------------------------------------");
-			writeln("");
-
-			const ownProperties = childrenOfKind(symbol, 'property').own.filter(isNoKeyword).sort(sortByAlias);
-			if ( sMetaType === "class" ) {
-				comment(symbol, sMetaType);
-				writeln(symbol.longname + " = function(" + signature(symbol) + ") {};");
-				for ( let memberId in ownProperties ) {
-					const member = ownProperties[memberId];
-					comment(member, sMetaType);
-					writeln(qname(member, symbol) + " = " + value(member));
-					writeln("");
-				}
-			} else if ( sMetaType === 'namespace' || sMetaType === 'enum' ) {
-			//debug(`found namespace ${symbol.longname}`);
-			//debug(ownProperties);
-				if ( ownProperties.length ) {
-					writeln("// dummy function to make Eclipse aware of namespace");
-					writeln(symbol.longname + ".toString = function() { return \"\"; };");
-				}
-			}
-
-			const ownEvents = childrenOfKind(symbol, 'event').own.filter(isNoKeyword).sort(sortByAlias);
-			if ( ownEvents.length ) {
-				for ( let memberId in ownEvents ) {
-					const member = ownEvents[memberId];
-					comment(member, sMetaType);
-					writeln(qname(member, symbol) + " = function(" + signature(member) + ") { " + retvalue(member) + " };");
-					writeln("");
-				}
-			}
-
-			const ownMethods = childrenOfKind(symbol, 'method').own.filter(isNoKeyword).sort(sortByAlias);
-			if ( ownMethods.length ) {
-				for (let memberId in ownMethods ) {
-					const member = ownMethods[memberId];
-					comment(member, sMetaType);
-					writeln(qname(member, symbol) + " = function(" + signature(member) + ") { " + retvalue(member) + " };");
-					writeln("");
-				}
-			}
-
-		}
-	});
-
-	writeln("// ---- static fields of namespaces ---------------------------------------------------------------------");
-
-	sortedSymbols.forEach((symbol) => {
-
-		const sMetaType = (symbol.kind === 'member' && symbol.isEnum) ? 'enum' : symbol.kind;
-
-		if ( sMetaType === 'namespace' || sMetaType === 'enum' ) {
-
-			const ownProperties = childrenOfKind(symbol, 'property').own.filter(isNoKeyword).sort(sortByAlias);
-			if ( ownProperties.length ) {
-				writeln("");
-				writeln("// ---- " + symbol.longname + " --------------------------------------------------------------------------");
-				writeln("");
-
-				for (let memberId in ownProperties ) {
-					const member = ownProperties[memberId];
-					comment(member, sMetaType);
-					writeln(qname(member, symbol) + " = " + value(member) + ";");
-					writeln("");
-				}
-			}
-		}
-
-	});
-
-	fs.mkPath(path.dirname(filename));
-	fs.writeFileSync(filename, output.join(""), 'utf8');
-	info(`  saved as ${filename}`);
-}
-
 // Description + Settings
 
 function getConstructorDescription(symbol) {