@ui5/builder 4.0.4 → 4.0.5

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

@@ -5,9 +5,7 @@
  * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
  */
 
-/* global env: true */
-/* eslint-env es6,node */
-/* eslint strict: [2, "global"] */
+/* global env */
 
 "use strict";
 
@@ -27,6 +25,7 @@ const warning = logger.warn.bind(logger);
 const error = logger.error.bind(logger);
 
 const {extractVersion, extractSince} = require("./utils/versionUtil");
+const {ASTBuilder, TypeParser} = require("./utils/typeParser");
 
 /* errors that might fail the build in future */
 function future(msg) {
@@ -42,39 +41,7 @@ function future(msg) {
 /* globals, constants */
 const MY_TEMPLATE_NAME = "ui5",
 	MY_ALT_TEMPLATE_NAME = "sapui5-jsdoc3",
-	ANONYMOUS_LONGNAME = doclet.ANONYMOUS_LONGNAME,
-	A_SECURITY_TAGS = [
-		{
-			name : "SecSource",
-			caption : "Taint Source",
-			description : "APIs that might introduce tainted data into an application, e.g. due to user input or network access",
-			params : ["out","flags"]
-		},
-		{
-			name : "SecEntryPoint",
-			caption : "Taint Entry Point",
-			description: "APIs that are called implicitly by a framework or server and trigger execution of application logic",
-			params : ["in","flags"]
-		},
-		{
-			name : "SecSink",
-			caption : "Taint Sink",
-			description : "APIs that pose a security risk when they receive tainted data",
-			params : ["in","flags"]
-		},
-		{
-			name : "SecPassthrough",
-			caption : "Taint Passthrough",
-			description : "APIs that might propagate tainted data when they receive it as input",
-			params : ["in","out","flags"]
-		},
-		{
-			name : "SecValidate",
-			caption : "Validation",
-			description : "APIs that (partially) cleanse tainted data so that it no longer poses a security risk in the further data flow of an application",
-			params : ["in","out","flags"]
-		}
-	];
+	ANONYMOUS_LONGNAME = doclet.ANONYMOUS_LONGNAME;
 
 const templatesConf = (env.conf.templates || {}),
 	templateConf = templatesConf[MY_TEMPLATE_NAME] || templatesConf[MY_ALT_TEMPLATE_NAME] || {};
@@ -83,7 +50,7 @@ let conf = {};
 
 let __symbols;
 let __longnames;
-let __missingLongnames = {};
+const __missingLongnames = {};
 
 function merge(target, source) {
 	if ( source != null ) {
@@ -119,7 +86,7 @@ function lookup(key) {
 function createSymbol(longname, lines = []) {
 	const comment = [
 		"@name " + longname,
-		... lines
+		...lines
 	];
 
 	const symbol = new doclet.Doclet("/**\n * " + comment.join("\n * ") + "\n */", {});
@@ -215,7 +182,7 @@ function writeSymbols(symbols, filename, caption) {
 				v.base = value.base.longname;
 			}
 			if ( value.implementations ) {
-				v.base = value.implementations.map(($)=> $.longname);
+				v.base = value.implementations.map(($) => $.longname);
 			}
 			if ( value.parent ) {
 				v.parent = value.parent.longname;
@@ -454,7 +421,7 @@ function createInheritanceTree(allSymbols) {
 			} else {
 				warning(`create missing class ${sClass} (extended by ${sExtendingClass})`);
 			}
-			let oBaseClass = getOrCreateClass(sBaseClass, sClass);
+			const oBaseClass = getOrCreateClass(sBaseClass, sClass);
 			oClass = createSymbol(sClass, [
 				"@extends " + sBaseClass,
 				"@" + sKind,
@@ -485,7 +452,7 @@ function createInheritanceTree(allSymbols) {
 			aRootTypes.push(oClass);
 		}
 
-		let oBaseClass = getOrCreateClass(sBaseClass, oClass.longname);
+		const oBaseClass = getOrCreateClass(sBaseClass, oClass.longname);
 		oClass.__ui5.base = oBaseClass;
 		oBaseClass.__ui5.derived = oBaseClass.__ui5.derived || [];
 		oBaseClass.__ui5.derived.push(oClass);
@@ -667,60 +634,8 @@ function sortByAlias(a, b) {
 	return 0;
 }
 
-/* Make a symbol sorter by some attribute. */
-function makeSortby(/* fields ...*/) {
-	const aFields = Array.prototype.slice.apply(arguments),
-		aNorms = [],
-		aFuncs = [];
-	for (let i = 0; i < arguments.length; i++) {
-		aNorms[i] = 1;
-		if ( typeof aFields[i] === 'function' ) {
-			aFuncs[i] = aFields[i];
-			continue;
-		}
-		aFuncs[i] = function($,n) { return $[n]; };
-		if ( aFields[i].indexOf("!") === 0 ) {
-			aNorms[i] = -1;
-			aFields[i] = aFields[i].slice(1);
-		}
-		if ( aFields[i] === 'deprecated' ) {
-			aFuncs[i] = function($,n) { return !!$[n]; };
-		} else if ( aFields[i] === 'static' ) {
-			aFields[i] = 'scope';
-			aFuncs[i] = function($,n) { return $[n] === 'static'; };
-		} else if ( aFields[i].indexOf("#") === 0 ) {
-			aFields[i] = aFields[i].slice(1);
-			aFuncs[i] = function($,n) { return $.comment.getTag(n).length > 0; };
-		}
-	}
-	return function(a, b) {
-		// debug(`compare ${a.longname} : ${b.longname}`);
-		let r = 0;
-		for (let i = 0; r === 0 && i < aFields.length; i++) {
-			let va = aFuncs[i](a,aFields[i]);
-			let vb = aFuncs[i](b,aFields[i]);
-			if ( va && !vb ) {
-				r = -aNorms[i];
-			} else if ( !va && vb ) {
-				r = aNorms[i];
-			} else if ( va && vb ) {
-				va = String(va).toLowerCase();
-				vb = String(vb).toLowerCase();
-				if (va < vb) {
-					r = -aNorms[i];
-				}
-				if (va > vb) {
-					r = aNorms[i];
-				}
-			}
-			// debug(`  ${aFields[i]}: ${va} ? ${vb} = ${r}`);
-		}
-		return r;
-	};
-}
-
 function getMembersOfKind(data, kind) {
-	let oResult = [];
+	const oResult = [];
 	//debug(`calculating kind ${kind} from ${data.longname}`);
 	//console.log(data);
 	let fnFilter;
@@ -759,94 +674,6 @@ function getMembersOfKind(data, kind) {
 
 // ---- type parsing ---------------------------------------------------------------------------------------------
 
-class ASTBuilder {
-	literal(str) {
-		return {
-			type: "literal",
-			value: str
-		};
-	}
-	simpleType(type) {
-		return {
-			type: "simpleType",
-			name: type
-		};
-	}
-	array(componentType) {
-		return {
-			type: "array",
-			component: componentType
-		};
-	}
-	object(keyType, valueType) {
-		return {
-			type: "object",
-			key: keyType,
-			value: valueType
-		};
-	}
-	set(elementType) {
-		return {
-			type: "set",
-			element: elementType
-		};
-	}
-	promise(fulfillmentType) {
-		return {
-			type: "promise",
-			fulfill: fulfillmentType
-		};
-	}
-	"function"(paramTypes, returnType, thisType, constructorType) {
-		return {
-			"type": "function",
-			"params": paramTypes,
-			"return": returnType,
-			"this": thisType,
-			"constructor": constructorType
-		};
-	}
-	structure(structure) {
-		return {
-			type: "structure",
-			fields: structure
-		};
-	}
-	union(types) {
-		return {
-			type: "union",
-			types: types
-		};
-	}
-	synthetic(type) {
-		type.synthetic = true;
-		return type;
-	}
-	nullable(type) {
-		type.nullable = true;
-		return type;
-	}
-	mandatory(type) {
-		type.mandatory = true;
-		return type;
-	}
-	optional(type) {
-		type.optional = true;
-		return type;
-	}
-	repeatable(type) {
-		type.repeatable = true;
-		return type;
-	}
-	typeApplication(type, templateTypes) {
-		return {
-			type: "typeApplication",
-			baseType: type,
-			templateTypes: templateTypes
-		};
-	}
-}
-
 class TypeStringBuilder {
 	constructor() {
 		this.lt = "<";
@@ -906,7 +733,7 @@ class TypeStringBuilder {
 	"function"(paramTypes, returnType) {
 		return {
 			simpleComponent: false,
-			str: "function(" + paramTypes.map(type => type.str).join(',') + ")" + ( returnType ? " : " + this.safe(returnType) : "")
+			str: "function(" + paramTypes.map((type) => type.str).join(',') + ")" + ( returnType ? " : " + this.safe(returnType) : "")
 		};
 	}
 	structure(structure) {
@@ -934,7 +761,7 @@ class TypeStringBuilder {
 	union(types) {
 		return {
 			needsParenthesis: true,
-			str: types.map(type => this.safe(type)).join('|')
+			str: types.map((type) => this.safe(type)).join('|')
 		};
 	}
 	synthetic(type) {
@@ -960,248 +787,11 @@ class TypeStringBuilder {
 	typeApplication(type, templateTypes) {
 		return {
 			simpleComponent: false,
-			str: this.safe(type) + this.lt + templateTypes.map(type => this.safe(type)).join(',') + this.gt
+			str: this.safe(type) + this.lt + templateTypes.map((type) => this.safe(type)).join(',') + this.gt
 		};
 	}
 }
 
-function TypeParser(defaultBuilder = new ASTBuilder()) {
-	const rLexer = /\s*(Array\.?<|Object\.?<|Set\.?<|Promise\.?<|function\(|\{|:|\(|\||\}|\.?<|>|\)|,|\[\]|\*|\?|!|=|\.\.\.)|\s*(false|true|(?:\+|-)?(?:\d+(?:\.\d+)?|NaN|Infinity)|'[^']*'|"[^"]*"|null|undefined)|\s*((?:module:)?\w+(?:[/.#~][$\w_]+)*)|./g;
-
-	let input;
-	let builder;
-	let token;
-	let tokenStr;
-
-	function next(expected) {
-		if ( expected !== undefined && token !== expected ) {
-			throw new SyntaxError(
-				`TypeParser: expected '${expected}', but found '${tokenStr}' ` +
-				`(pos: ${rLexer.lastIndex}, input='${input}')`
-			);
-		}
-		const match = rLexer.exec(input);
-		if ( match ) {
-			tokenStr = match[1] || match[2] || match[3];
-			token = match[1] || (match[2] && "literal") || (match[3] && "symbol");
-			if ( !token ) {
-				throw new SyntaxError(`TypeParser: unexpected '${match[0]}' (pos: ${match.index}, input='${input}')`);
-			}
-		} else {
-			tokenStr = token = null;
-		}
-	}
-
-	function parseType() {
-		let nullable = false;
-		let mandatory = false;
-		if ( token === "?" ) {
-			next();
-			nullable = true;
-		} else if ( token === "!" ) {
-			next();
-			mandatory = true;
-		}
-
-		let type;
-
-		if ( token === "literal" ) {
-			type = builder.literal(tokenStr);
-			next();
-		} else if ( token === "Array.<" || token === "Array<" ) {
-			next();
-			const componentType = parseTypes();
-			next(">");
-			type = builder.array(componentType);
-		} else if ( token === "Object.<" || token === "Object<" ) {
-			next();
-			let keyType;
-			let valueType = parseTypes();
-			if ( token === "," ) {
-				next();
-				keyType = valueType;
-				valueType = parseTypes();
-			} else {
-				keyType = builder.synthetic(builder.simpleType("string"));
-			}
-			next(">");
-			type = builder.object(keyType, valueType);
-		} else if ( token === "Set.<" || token === "Set<" ) {
-			next();
-			const elementType = parseTypes();
-			next(">");
-			type = builder.set(elementType);
-		} else if ( token === "Promise.<" || token === "Promise<" ) {
-			next();
-			const resultType = parseTypes();
-			next(">");
-			type = builder.promise(resultType);
-		} else if ( token === "function(" ) {
-			next();
-			let thisType;
-			let constructorType;
-			const paramTypes = [];
-			let returnType;
-			if ( tokenStr === "this" ) {
-				next();
-				next(":");
-				thisType = parseType();
-				if ( token !== ")" ) {
-					next(",");
-				}
-			} else if ( tokenStr === "new" ) {
-				next();
-				next(":");
-				constructorType = parseType();
-				if ( token !== ")" ) {
-					next(",");
-				}
-			}
-			while ( token !== ")" ) {
-				const repeatable = token === "...";
-				if ( repeatable ) {
-					next();
-				}
-				let paramType = parseTypes();
-				if ( repeatable ) {
-					paramType = builder.repeatable(paramType);
-				}
-				const optional = token === "=";
-				if ( optional ) {
-					paramType = builder.optional(paramType);
-					next();
-				}
-				paramTypes.push(paramType);
-
-				// exit if there are no more parameters
-				if ( token !== "," ) {
-					break;
-				}
-
-				if ( repeatable ) {
-					throw new SyntaxError(
-						`TypeParser: only the last parameter of a function can be repeatable ` +
-						`(pos: ${rLexer.lastIndex}, input='${input}')`
-					);
-				}
-
-				// consume the comma
-				next();
-			}
-			next(")");
-			if ( token === ":" ) {
-				next(":");
-				returnType = parseType();
-			}
-			type = builder.function(paramTypes, returnType, thisType, constructorType);
-		} else if ( token === "{" ) {
-			const structure = Object.create(null);
-			next();
-			do {
-				const propName = tokenStr;
-				if ( !/^\w+$/.test(propName) ) {
-					throw new SyntaxError(
-						`TypeParser: structure field must have a simple name ` +
-						`(pos: ${rLexer.lastIndex}, input='${input}', field:'${propName}')`
-					);
-				}
-				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;
-				}
-				next(",");
-			} while (token);
-			next("}");
-			type = builder.structure(structure);
-		} else if ( token === "(" ) {
-			next();
-			type = parseTypes();
-			next(")");
-		} else if ( token === "*" ) {
-			next();
-			type = builder.simpleType("*");
-		} else {
-			type = builder.simpleType(tokenStr);
-			next("symbol");
-			// check for suffix operators: either 'type application' (generics) or 'array', but not both of them
-			if ( token === "<" || token === ".<" ) {
-				next();
-				const templateTypes = [];
-				do {
-					const templateType = parseTypes();
-					templateTypes.push(templateType);
-					if ( token === ">" ) {
-						break;
-					}
-					next(",");
-				} while (token);
-				next(">");
-				type = builder.typeApplication(type, templateTypes);
-			} else {
-				while ( token === "[]" ) {
-					next();
-					type = builder.array(type);
-				}
-			}
-		}
-		if ( builder.normalizeType ) {
-			type = builder.normalizeType(type);
-		}
-		if ( nullable ) {
-			type = builder.nullable(type);
-		}
-		if ( mandatory ) {
-			type = builder.mandatory(type);
-		}
-		return type;
-	}
-
-	function parseTypes() {
-		const types = [];
-		do {
-			types.push(parseType());
-			if ( token !== "|" ) {
-				break;
-			}
-			next();
-		} while (token);
-		return types.length === 1 ? types[0] : builder.union(types);
-	}
-
-	this.parse = function(typeStr, tempBuilder = defaultBuilder) {
-		/*
-		try {
-			const r = catharsis.parse(typeStr, { jsdoc: true});
-			console.log(JSON.stringify(typeStr, null, "\t"), r);
-		} catch (err) {
-			console.log(typeStr, err);
-		}
-		*/
-		builder = tempBuilder;
-		input = String(typeStr);
-		rLexer.lastIndex = 0;
-		next();
-		const type = parseTypes();
-		next(null);
-		return type;
-	};
-}
-
 const typeParser = new TypeParser();
 const _TEXT_BUILDER = new TypeStringBuilder();
 
@@ -1235,6 +825,7 @@ function _processTypeString(type, builder) {
 			return type;
 		}
 	}
+	return undefined;
 }
 
 function listTypes(type) {
@@ -1341,13 +932,13 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 	const obj = [];
 	let curr = obj;
 	let attribForKind = 'kind';
-	let stack = [];
+	const stack = [];
 
 	function isEmpty(obj) {
 		if ( !obj ) {
 			return true;
 		}
-		for (let n in obj) {
+		for (const n in obj) {
 			if ( obj.hasOwnProperty(n) ) {
 				return false;
 			}
@@ -1448,7 +1039,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 		}
 		if (info.since === null) {
 			future(`**** Failed to parse version in string '${value}'. ` +
-				`Version might be missing or has an unexpected format.`)
+				`Version might be missing or has an unexpected format.`);
 		}
 		if ( info.value ) {
 			curr["text"] = normalizeWS(info.value);
@@ -1513,7 +1104,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 		if ( $.access === 'restricted' ) {
 			return $.__ui5.stakeholders;
 		}
-		// return undefined
+		return undefined;
 	}
 
 	function exceptions(symbol) {
@@ -1604,7 +1195,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 
 		if ( metadata.specialSettings && Object.keys(metadata.specialSettings).length > 0 ) {
 			collection("specialSettings");
-			for ( let n in metadata.specialSettings ) {
+			for ( const n in metadata.specialSettings ) {
 				const special = metadata.specialSettings[n];
 				tag("specialSetting");
 				attrib("name", special.name);
@@ -1625,7 +1216,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 
 		if ( metadata.properties && Object.keys(metadata.properties).length > 0 ) {
 			collection("properties");
-			for ( let n in metadata.properties ) {
+			for ( const n in metadata.properties ) {
 				const prop = metadata.properties[n];
 				let defaultValue = prop.defaultValue != null ? prop.defaultValue.value : null;
 				// JSON can't transport a value of undefined, so represent it as string
@@ -1670,7 +1261,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 
 		if ( metadata.aggregations && Object.keys(metadata.aggregations).length > 0 ) {
 			collection("aggregations");
-			for ( let n in metadata.aggregations ) {
+			for ( const n in metadata.aggregations ) {
 				const aggr = metadata.aggregations[n];
 				tag("aggregation");
 				attrib("name", aggr.name);
@@ -1707,7 +1298,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 
 		if ( metadata.associations && Object.keys(metadata.associations).length > 0 ) {
 			collection("associations");
-			for ( let n in metadata.associations ) {
+			for ( const n in metadata.associations ) {
 				const assoc = metadata.associations[n];
 				tag("association");
 				attrib("name", assoc.name);
@@ -1731,7 +1322,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 
 		if ( metadata.events && Object.keys(metadata.events).length > 0 ) {
 			collection("events");
-			for ( let n in metadata.events ) {
+			for ( const n in metadata.events ) {
 				const event = metadata.events[n];
 				tag("event");
 				attrib("name", event.name);
@@ -1751,7 +1342,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 				tagWithSince("deprecated", event.deprecation);
 				if ( event.parameters && Object.keys(event.parameters).length > 0 ) {
 					tag("parameters");
-					for ( let pn in event.parameters ) {
+					for ( const pn in event.parameters ) {
 						if ( event.parameters.hasOwnProperty(pn) ) {
 							const param = event.parameters[pn];
 							tag(pn);
@@ -1774,7 +1365,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 
 		if ( metadata.annotations && Object.keys(metadata.annotations).length > 0 ) {
 			collection("annotations");
-			for ( let n in metadata.annotations ) {
+			for ( const n in metadata.annotations ) {
 				const anno = metadata.annotations[n];
 				tag("annotation");
 				attrib("name", anno.name);
@@ -2308,7 +1899,7 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 		if ( symbol.__ui5.stereotype !== 'xmlmacro' && ownMethods.length > 0 ) {
 			collection("methods");
 			ownMethods.forEach(function(member) {
-				writeMethod(member, undefined, symbol.kind === 'interface' || symbol.kind === 'class');
+				writeMethod(member, undefined, symbol.kind === 'interface' || symbol.kind === 'class');
 				if ( member.__ui5.members ) {
 					// HACK: export nested static functions as siblings of the current function
 					// A correct representation has to be discussed with the SDK / WebIDE
@@ -2377,7 +1968,7 @@ function postProcessAPIJSON(api) {
 	function guessExports(moduleName, symbols) {
 
 		// a non-stringifiable special value for unresolved exports
-		let UNRESOLVED = function() {};
+		const UNRESOLVED = function() {};
 
 		symbols = symbols.sort((a,b) => {
 			if ( a.name === b.name ) {
@@ -2457,7 +2048,7 @@ function postProcessAPIJSON(api) {
 
 	}
 
-	for ( let n in modules ) {
+	for ( const n in modules ) {
 		guessExports(n, modules[n]);
 	}
 
@@ -2478,7 +2069,7 @@ function postProcessAPIJSON(api) {
 			}
 			symbol = findSymbol(symbol.extends);
 		}
-		// return undefined
+		return undefined;
 	}
 
 	// See sap/ui/base/ManagedObjectMetadata
@@ -2525,6 +2116,37 @@ function postProcessAPIJSON(api) {
 					`doesn't match containing library '${api.library}'. Library must be explicitly defined in class metadata!`);
 			}
 		}
+		if (Array.isArray(symbol["ui5-metadata"].properties)) {
+			for (const prop of symbol["ui5-metadata"].properties) {
+				let moduleType;
+				// cut off array brackets for symbol lookup
+				const arrType = isArrayType(prop.type);
+				let lookupType = prop.type;
+				if (arrType) {
+					lookupType = lookupType.replace("[]", "");
+				}
+				if (prop.dataType === undefined
+					&& findSymbol(lookupType) == null
+					&& !lookupType?.startsWith("module:")
+					&& findSymbol(moduleType = `module:${lookupType.replace(/\./g, "/")}`) != null) {
+					// note: the dataType must be the original, including array brackets if present
+					prop.dataType = prop.type;
+					// the moduleType also needs to include the array brackets if present in the original dataType
+					prop.type = moduleType + (arrType ? "[]" : "");
+					for (const methodName of prop.methods) {
+						const method = symbol.methods?.find((m) => m.name === methodName);
+						if (methodName.startsWith("get")
+							&& method?.returnValue?.type === prop.dataType) {
+							method.returnValue.type = prop.type;
+						} else if (methodName.startsWith("set")
+							&& method?.parameters?.[0]?.type === prop.dataType) {
+							method.parameters[0].type = prop.type;
+						}
+					}
+					info(`${symbol.name}: adapted type of ${prop.name} and its accessors from '${prop.dataType}' to '${prop.type}'`);
+				}
+			}
+		}
 	});
 
 }
@@ -2568,16 +2190,22 @@ const builtinTypes = {
 	Attr:true,
 	Blob:true,
 	DataTransfer:true,
+	DragEvent:true,
 	Document:true,
 	DOMException:true,
+	DOMRect:true,
 	Element:true,
 	Event:true,
 	File:true,
 	FileList:true,
+	FormData:true,
 	Headers:true,
 	HTMLDocument:true,
 	HTMLElement:true,
 	Node:true,
+	PerformanceResourceTiming:true,
+	Request:true,
+	Response:true,
 	Storage:true,
 	Touch:true,
 	TouchList:true,
@@ -2628,7 +2256,9 @@ function validateAPIJSON(api) {
 	// create map of defined symbols (built-in types, dependency libraries, current library)
 	const defined = Object.assign(Object.create(null), builtinTypes, externalSymbols);
 	if ( api.symbols ) {
-		api.symbols.forEach((symbol) => defined[symbol.name] = symbol);
+		api.symbols.forEach((symbol) => {
+			defined[symbol.name] = symbol;
+		});
 	}
 
 	const naming = Object.create(null);
@@ -2783,12 +2413,10 @@ function validateAPIJSON(api) {
 								if ( !intfParam.optional ) {
 									reportError(oIntfAPI.name, `parameter ${intfParam.name} missing in implementation of ${symbol.name}#${intfMethod.name}`);
 								}
-							} else {
-								if ( implParam.type !== intfParam.type ) {
-									reportError(oIntfAPI.name, `type of parameter ${intfParam.name} of interface method differs from type in implementation ${symbol.name}#${intfMethod.name}`);
-								}
-								// TODO check nested properties
+							} else if ( implParam.type !== intfParam.type ) {
+								reportError(oIntfAPI.name, `type of parameter ${intfParam.name} of interface method differs from type in implementation ${symbol.name}#${intfMethod.name}`);
 							}
+							// TODO check nested properties
 						});
 					}
 					if ( intfMethod.returnValue != null && implMethod.returnValue == null ) {
@@ -2830,7 +2458,7 @@ function validateAPIJSON(api) {
 		if ( symbol.implements ) {
 			symbol.implements.forEach((intf) => {
 				checkSimpleType(intf, `interface of ${symbol.name}`);
-				let oIntfAPI = defined[intf];
+				const oIntfAPI = defined[intf];
 				if ( oIntfAPI ) {
 					checkClassAgainstInterface(symbol, oIntfAPI);
 				}
@@ -3085,6 +2713,7 @@ function createAPIXML(symbols, filename, options = {}) {
 	 */
 	function toRaw(value, type) {
 		if ( typeof value === "string" && !isEnum(type) ) {
+			// eslint-disable-next-line no-control-regex
 			return "\"" + value.replace(/[\u0000-\u001f"\\]/g,
 				(c) => replacement[c] || "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0")) + "\"";
 		}
@@ -3229,7 +2858,7 @@ function createAPIXML(symbols, filename, options = {}) {
 				tagWithSince("deprecated", event.deprecated);
 				if ( event.parameters ) {
 					tag("parameters");
-					for ( let pn in event.parameters ) {
+					for ( const pn in event.parameters ) {
 						if ( event.parameters.hasOwnProperty(pn) ) {
 							const param = event.parameters[pn];
 
@@ -3374,7 +3003,7 @@ function createAPIXML(symbols, filename, options = {}) {
 		let count = 0;
 
 		if ( props ) {
-			for (let n in props ) {
+			for (const n in props ) {
 				if ( props.hasOwnProperty(n) ) {
 
 					param = props[n];
@@ -3526,7 +3155,7 @@ function createAPIXML(symbols, filename, options = {}) {
 						}
 
 						if ( !legacyContent ) {
-							if ( hasSettings && j == 1 && /setting/i.test(param.name) && /object/i.test(param.type) ) {
+							if ( hasSettings && j === 1 && /setting/i.test(param.name) && /object/i.test(param.type) ) {
 								if ( addRedundancy ) {
 									tag("parameterProperties");
 									writeParameterPropertiesForMSettings(symbolAPI);