| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * 'License'); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| /** |
| * Convert the typedefinitions bundled with the typescript compiler into the |
| * stub files used by NetBeans (module webcommon/javascript2.editor). |
| * |
| * Usage: |
| * - Run 'npm install' to initialize the node modules |
| * - Run 'npm run generate' to start the build process |
| * |
| * The resulting zip files are placed in the 'out' directory. The generated |
| * sources can be found in the child folders of the 'out' directory. |
| */ |
| |
| import ts from 'typescript'; |
| import process from 'process'; |
| import fs from 'fs'; |
| import JSZip from 'jszip'; |
| |
| /******************************************************************************* |
| * Datastructures to hold type data while parsing |
| ******************************************************************************/ |
| |
| class TypeData { |
| modules: Map<string,ModuleInfo> = new Map(); |
| |
| getModule(moduleName: string): ModuleInfo { |
| if(! this.modules.has(moduleName)) { |
| const mi = new ModuleInfo(); |
| this.modules.set(moduleName, mi); |
| } |
| return this.modules.get(moduleName)!; |
| } |
| } |
| |
| class ModuleInfo { |
| aliases: Map<string,ts.TypeNode> = new Map(); |
| classes: Map<string,ClassInfo> = new Map(); |
| functions: Map<string,MemberInfo> = new Map(); |
| variables: Map<string,MemberInfo> = new Map(); |
| |
| public getClass(className: string): ClassInfo { |
| if (!this.classes.has(className)) { |
| const ci = new ClassInfo(); |
| this.classes.set(className, ci); |
| } |
| return this.classes.get(className)!; |
| } |
| } |
| |
| class ClassInfo { |
| doc: string | undefined; |
| inherits: string[] = []; |
| constructorInfo: MemberInfo[] = []; |
| properties: Map<string,MemberInfo> = new Map(); |
| file: string[] = []; |
| |
| public addInterits(ancestor: string) { |
| if(this.inherits.indexOf(ancestor) < 0) { |
| this.inherits.push(ancestor); |
| } |
| } |
| |
| public addFile(file: string) { |
| if(this.file.indexOf(file) < 0) { |
| this.file.push(file); |
| } |
| } |
| } |
| |
| class MemberInfo { |
| constructor(callable: boolean, returnType: ts.TypeNode, doc: string, file: string, parameters: {name: string, type: ts.TypeNode, doc: string, optional: boolean}[] | undefined = undefined) { |
| this.callable = callable; |
| this.returnType = returnType; |
| this.doc = doc; |
| this.parameters = parameters ? parameters : []; |
| this.file = file; |
| }; |
| |
| doc: string; |
| returnType: ts.TypeNode; |
| callable: boolean; |
| parameters: {name: string, type: ts.TypeNode, doc: string, optional: boolean}[]; |
| file: string; |
| } |
| |
| class TypeInfo { |
| constructor(jsType: string, jsDocType: string[], addDoc: string | undefined = undefined) { |
| this.addDoc = addDoc; |
| this.jsdocType = jsDocType; |
| this.jsType = jsType; |
| } |
| |
| /** |
| * Original definition of the type |
| */ |
| addDoc: string | undefined; |
| /** |
| * JS mapping of the type definition |
| */ |
| jsType: string; |
| /** |
| * JSDoc mapping of the type definition |
| */ |
| jsdocType: string[] = []; |
| |
| toJsDocDeclaration(): string { |
| return this.jsdocType.length == 1 ? this.jsdocType[0] : ('(' + this.jsdocType.join(' | ') + ')'); |
| } |
| } |
| |
| /** |
| * Merge supplied arguments using the separator. False arguements are removed |
| * and not merged into the final string |
| */ |
| function join(separator: string, ...args: Array<string|undefined>) { |
| return args |
| .filter(arg => arg && arg.trim() !== '') |
| .join(separator); |
| } |
| |
| /** |
| * Extract TypeInfo from the supplied type node |
| */ |
| function toTypeName(propertyType: ts.Node | undefined, moduleInfo: ModuleInfo, parentType: string | undefined = undefined, originalDefinition: string | undefined = undefined): TypeInfo { |
| if (!propertyType) { |
| return new TypeInfo('undefined', ['undefined']); |
| } |
| let result = propertyType.getText(); |
| let arrayDeep = 0; |
| while (propertyType && propertyType.kind === ts.SyntaxKind.ArrayType) { |
| arrayDeep++; |
| propertyType = (<ts.ArrayTypeNode>propertyType).elementType; |
| } |
| if (arrayDeep > 0 && propertyType.kind === ts.SyntaxKind.TypeReference) { |
| let realPropertyType = (<ts.TypeReferenceNode>propertyType).typeName; |
| return new TypeInfo('new Array()', |
| [(realPropertyType.kind === ts.SyntaxKind.QualifiedName |
| ? realPropertyType.getText() |
| : 'text' in realPropertyType |
| ? realPropertyType.text |
| : realPropertyType) + '[]'.repeat(arrayDeep)], result); |
| } |
| if (propertyType.kind === ts.SyntaxKind.AnyKeyword) { |
| return new TypeInfo('new Object()', ['Object'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.StringKeyword) { |
| return new TypeInfo('new String()', ['String'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.NumberKeyword) { |
| return new TypeInfo('new Number()', ['Number'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.UnknownKeyword) { |
| return new TypeInfo('undefined', ['Object'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.BooleanKeyword) { |
| return new TypeInfo('new Boolean()', ['Boolean'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.VoidKeyword) { |
| return new TypeInfo('undefined', ['undefined'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.ObjectKeyword) { |
| return new TypeInfo('new Object()', ['Object'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.UndefinedKeyword) { |
| return new TypeInfo('undefined', ['undefined'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.LiteralType) { |
| return new TypeInfo(result, [result], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.BigIntKeyword) { |
| return new TypeInfo('BigInt(0)', ['BigInt'], originalDefinition); |
| } else if (parentType && propertyType.kind === ts.SyntaxKind.ThisType) { |
| return new TypeInfo('new ' + parentType + '()', [parentType], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.SymbolKeyword) { |
| return new TypeInfo('new Symbol()', ['Symbol'], originalDefinition); |
| } else if (result === 'unique symbol') { |
| return new TypeInfo('new Symbol()', ['Symbol'], originalDefinition); |
| } else if (propertyType.kind === ts.SyntaxKind.FunctionType) { |
| return new TypeInfo('new Function()', ['Function'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.ConstructorType) { |
| return new TypeInfo('new Function()', ['Function'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.TupleType) { |
| return new TypeInfo('new Object()', ['Object'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.TypeLiteral) { |
| // XXXX |
| return new TypeInfo('new Object()', ['Object'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.FirstTypeNode) { |
| return new TypeInfo('new Boolean()', ['Boolean'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.TypeQuery) { |
| const entityName = (propertyType as ts.TypeQueryNode).exprName; |
| let typeName = 'undefined'; |
| if(entityName.kind == ts.SyntaxKind.Identifier) { |
| typeName = (entityName as ts.Identifier).text; |
| } else if (entityName.kind == ts.SyntaxKind.QualifiedName) { |
| typeName = (entityName as ts.QualifiedName).getText(); |
| } |
| return new TypeInfo('new ' + typeName + '()', [typeName], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.TypeOperator) { |
| return toTypeName((propertyType as ts.TypeOperatorNode).type, moduleInfo, parentType, originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.TypeReference) { |
| let realPropertyType = (<ts.TypeReferenceNode>propertyType).typeName; |
| if (moduleInfo.aliases.has(realPropertyType.getText())) { |
| return toTypeName( |
| moduleInfo.aliases.get(realPropertyType.getText())!, |
| moduleInfo, |
| parentType, |
| originalDefinition ? originalDefinition : realPropertyType.getText() |
| ); |
| } else { |
| const type = checker.getTypeAtLocation(propertyType); |
| const symbol = type.symbol || type.aliasSymbol; |
| let jsType = 'new Object()'; |
| let jsdocType = 'Object'; |
| if (symbol) { |
| const decls = symbol.getDeclarations() as ts.Declaration[]; |
| let referencesInterface: boolean = false; |
| decls.forEach(d => { |
| if (d.kind == ts.SyntaxKind.InterfaceDeclaration) { |
| referencesInterface = true; |
| } |
| }); |
| if (referencesInterface) { |
| jsType = 'new ' + realPropertyType.getText() + '()'; |
| jsdocType = realPropertyType.getText(); |
| if ((!moduleInfo.classes.has(jsdocType)) && (moduleInfo.aliases.has(jsdocType))) { |
| return toTypeName( |
| moduleInfo.aliases.get(jsdocType)!, |
| moduleInfo, |
| parentType, |
| originalDefinition ? originalDefinition : realPropertyType.getText() |
| ); |
| } |
| } |
| } else if (type.flags == ts.TypeFlags.Number) { |
| jsType = 'new Number()'; |
| jsdocType = 'Number'; |
| } |
| return new TypeInfo(jsType, [jsdocType], originalDefinition ? originalDefinition : realPropertyType.getText()); |
| } |
| } else if (propertyType.kind === ts.SyntaxKind.IndexedAccessType && result === 'ArrayBufferTypes[keyof ArrayBufferTypes]') { |
| return new TypeInfo('new ArrayBuffer()', ['ArrayBuffer'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind === ts.SyntaxKind.UnionType) { |
| const types = (<ts.TypeNode[]> ((propertyType as any).types)) |
| .filter(t => t.kind !== ts.SyntaxKind.UndefinedKeyword && !(t.kind === ts.SyntaxKind.LiteralType && t.getText() === 'null') && t.kind !== ts.SyntaxKind.TypeQuery); |
| let reducedTypeInfo: TypeInfo | undefined = undefined; |
| if (types.length == 1) { |
| reducedTypeInfo = toTypeName(types[0], moduleInfo, parentType, originalDefinition ? originalDefinition : result); |
| } |
| |
| let jsdocType = (<ts.TypeNode[]> ((propertyType as any).types)) |
| .map(typeNode => toTypeName(typeNode, moduleInfo, parentType, originalDefinition ? originalDefinition : result)) |
| .map(ti => ti.jsdocType) |
| .flat(); |
| |
| if(reducedTypeInfo) { |
| return new TypeInfo(reducedTypeInfo.jsType, jsdocType, originalDefinition ? originalDefinition : result); |
| } else { |
| return new TypeInfo('new Object()', jsdocType, originalDefinition ? originalDefinition : result); |
| } |
| } else if (propertyType.kind === ts.SyntaxKind.IntersectionType) { |
| const types = (<ts.TypeNode[]> ((propertyType as any).types)) |
| .filter(t => t.kind !== ts.SyntaxKind.UndefinedKeyword && !(t.kind === ts.SyntaxKind.LiteralType && t.getText() === 'null') && t.kind !== ts.SyntaxKind.TypeQuery); |
| if (types.length == 1) { |
| return toTypeName(types[0], moduleInfo, parentType, originalDefinition ? originalDefinition : result); |
| } |
| return new TypeInfo('new Object()', ['Object'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind == ts.SyntaxKind.ParenthesizedType) { |
| return toTypeName((propertyType as ts.ParenthesizedTypeNode).type, moduleInfo, parentType, originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind == ts.SyntaxKind.ConditionalType && parentType === 'SubtleCrypto') { |
| return toTypeName(moduleInfo.aliases.get('KeyFormat'), moduleInfo, parentType, originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind == ts.SyntaxKind.MappedType && (parentType === 'ResponseInit' || parentType === 'RequestInit' || parentType === 'PushSubscriptionJSON')) { |
| return new TypeInfo('{}', ['Object.<String,String>'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind == ts.SyntaxKind.MappedType && (parentType === 'AudioWorkletNodeOptions')) { |
| return new TypeInfo('{}', ['Object.<String,Number>'], originalDefinition ? originalDefinition : result); |
| } else if (propertyType.kind == ts.SyntaxKind.MappedType && (parentType === 'Object')) { |
| return new TypeInfo('new Object()', ['Object'], originalDefinition ? originalDefinition : result); |
| } else { |
| console.log('Unhandled type code: ' + ts.SyntaxKind[propertyType.kind] + ' / ' + result + ' / ' + parentType); |
| return new TypeInfo('undefined', ['Object'], originalDefinition ? originalDefinition : result); |
| } |
| } |
| |
| /** |
| * Extract the string version of the member name from the property name node. |
| */ |
| function propertyNameToString(propertyName: ts.PropertyName): string { |
| switch (propertyName.kind) { |
| case ts.SyntaxKind.Identifier: return '.' + (propertyName as ts.Identifier).getText(); |
| case ts.SyntaxKind.StringLiteral: return '[' + (propertyName as ts.StringLiteral).getText() + ']'; |
| case ts.SyntaxKind.ComputedPropertyName: return (propertyName as ts.ComputedPropertyName).getText(); |
| default: 'UNHANDLED: ' + ts.SyntaxKind[propertyName.kind]; |
| } |
| return 'TS KAPUT'; |
| } |
| |
| |
| /******************************************************************************* |
| * Extract the type data from the typescript definition by running a visitor |
| * over the AST generated by the typescript parser. |
| ******************************************************************************/ |
| |
| let result = new TypeData(); |
| |
| let visit = function(sourceFile: ts.SourceFile, modulePrefix: string, iface: string) { |
| return (node: ts.Node) => { |
| switch (node.kind) { |
| // Handle type aliases so that they can be resolved after parsing is done |
| case ts.SyntaxKind.TypeAliasDeclaration: |
| result.getModule(modulePrefix).aliases.set( |
| (node as ts.TypeAliasDeclaration).name.getText(), |
| (node as ts.TypeAliasDeclaration).type |
| ); |
| break; |
| // Handle variable declarations - they are assumed to be instances |
| // declared at the module level |
| case ts.SyntaxKind.VariableStatement: |
| { |
| (<ts.VariableStatement>node).declarationList.declarations.forEach(decl => { |
| let declName = decl.name.getText(); |
| if (declName !== '.prototype' && declName !== '.constructor') { |
| let propertySymbol = checker.getSymbolAtLocation(decl); |
| let propertydoc = ''; |
| if (propertySymbol) { |
| propertydoc = ts.displayPartsToString(propertySymbol.getDocumentationComment(checker)); |
| } |
| |
| const propertyInfo = new MemberInfo( |
| false, |
| decl.type!, |
| propertydoc, |
| sourceFile.fileName |
| ); |
| |
| result.getModule(modulePrefix).variables.set(declName, propertyInfo); |
| }; |
| }); |
| } |
| break; |
| // Handle function declarations - they are assumed to be unbound |
| // functions declared at the module level |
| case ts.SyntaxKind.FunctionDeclaration: |
| if ((<ts.FunctionDeclaration>node).name) { |
| let functionName = propertyNameToString((<ts.FunctionDeclaration>node).name!); |
| let functionSymbol = ((node as any).symbol as ts.Symbol); |
| |
| const parameters: { name: string, type: ts.TypeNode, doc: string, optional: boolean }[] = []; |
| |
| for (const param of (<ts.MethodSignature>node).parameters) { |
| if (param.name.getText() == 'this') { |
| continue; |
| } |
| let paramSymbol = ((param as any).symbol) as ts.Symbol; |
| parameters.push({ |
| name: param.name.getText(), |
| type: param.type!, |
| doc: ts.displayPartsToString(paramSymbol.getDocumentationComment(checker)), |
| optional: !!param.questionToken |
| }); |
| } |
| |
| const functionInfo = new MemberInfo( |
| true, |
| (<ts.PropertySignature>node).type!, |
| ts.displayPartsToString(functionSymbol.getDocumentationComment(checker)), |
| sourceFile.fileName, |
| parameters |
| ); |
| |
| result.getModule(modulePrefix).functions.set(functionName, functionInfo); |
| } |
| break; |
| // Handle constructors |
| case ts.SyntaxKind.ConstructSignature: |
| const parameters: { name: string, type: ts.TypeNode, doc: string, optional: boolean }[] = []; |
| |
| for (const param of (<ts.ConstructSignatureDeclaration>node).parameters) { |
| if (param.name.getText() == 'this') { |
| continue; |
| } |
| let paramSymbol = ((param as any).symbol) as ts.Symbol; |
| parameters.push({ |
| name: param.name.getText(), |
| type: param.type!, |
| doc: ts.displayPartsToString(paramSymbol.getDocumentationComment(checker)), |
| optional: !!param.questionToken |
| }); |
| } |
| |
| let ifaceBase = iface; |
| if(iface.endsWith('Constructor')) { |
| ifaceBase = iface.substring(0, iface.length - 11); |
| } |
| |
| const mi = new MemberInfo( |
| true, |
| (<ts.ConstructSignatureDeclaration>node).type!, |
| '', |
| sourceFile.fileName, |
| parameters |
| ); |
| |
| result.getModule(modulePrefix).getClass(ifaceBase).addFile(sourceFile.fileName); |
| result.getModule(modulePrefix).getClass(ifaceBase).constructorInfo.push(mi); |
| |
| break; |
| // Handle methods |
| case ts.SyntaxKind.MethodSignature: |
| let functionName = propertyNameToString((<ts.MethodSignature>node).name); |
| if (functionName !== '.prototype' && functionName !== '.constructor') { |
| let functionSymbol = ((node as any).symbol as ts.Symbol); |
| |
| const parameters: { name: string, type: ts.TypeNode, doc: string, optional: boolean }[] = []; |
| |
| for (const param of (<ts.MethodSignature>node).parameters) { |
| if (param.name.getText() == 'this') { |
| continue; |
| } |
| let paramSymbol = ((param as any).symbol) as ts.Symbol; |
| parameters.push({ |
| name: param.name.getText(), |
| type: param.type!, |
| doc: ts.displayPartsToString(paramSymbol.getDocumentationComment(checker)), |
| optional: !!param.questionToken |
| }); |
| } |
| |
| const functionInfo = new MemberInfo( |
| true, |
| (<ts.PropertySignature>node).type!, |
| ts.displayPartsToString(functionSymbol.getDocumentationComment(checker)), |
| sourceFile.fileName, |
| parameters |
| ); |
| |
| result.getModule(modulePrefix).getClass(iface).addFile(sourceFile.fileName); |
| result.getModule(modulePrefix).getClass(iface).properties.set(functionName, functionInfo); |
| } |
| break; |
| // Handle properties |
| case ts.SyntaxKind.PropertySignature: |
| let propertyName = propertyNameToString((<ts.PropertySignature>node).name); |
| if (propertyName !== '.prototype' && propertyName !== '.constructor') { |
| let propertySymbol = checker.getSymbolAtLocation(node); |
| let propertydoc = ''; |
| if (propertySymbol) { |
| propertydoc = ts.displayPartsToString(propertySymbol.getDocumentationComment(checker)); |
| } |
| |
| const propertyInfo = new MemberInfo( |
| false, |
| (<ts.PropertySignature>node).type!, |
| propertydoc, |
| sourceFile.fileName |
| ); |
| |
| result.getModule(modulePrefix).getClass(iface).addFile(sourceFile.fileName); |
| result.getModule(modulePrefix).getClass(iface).properties.set(propertyName, propertyInfo); |
| } |
| break; |
| // Handle module declarations - only handled to extract the name of the module |
| case ts.SyntaxKind.ModuleDeclaration: |
| let moduleName = (<ts.ModuleDeclaration>node).name.text; |
| modulePrefix = moduleName; |
| break; |
| // Handle interface declaration |
| case ts.SyntaxKind.InterfaceDeclaration: |
| iface = (<ts.InterfaceDeclaration>node).name.text; |
| break; |
| |
| default: |
| } |
| switch (node.kind) { |
| // For modules decend into their children |
| case ts.SyntaxKind.ModuleBlock: |
| ts.forEachChild(node, visit(sourceFile, modulePrefix, iface)); |
| break; |
| case ts.SyntaxKind.ModuleDeclaration: |
| ts.forEachChild(node, visit(sourceFile, modulePrefix, iface)); |
| modulePrefix = ''; |
| break; |
| // For interfaces decend into their children and extract the inheritence tree |
| case ts.SyntaxKind.InterfaceDeclaration: |
| ts.forEachChild(node, visit(sourceFile, modulePrefix, iface)); |
| const id = node as ts.InterfaceDeclaration; |
| let idSymbol = ((id as any).symbol) as ts.Symbol; |
| let idDoc = ''; |
| if (idSymbol) { |
| idDoc = ts.displayPartsToString(idSymbol.getDocumentationComment(checker)); |
| result.getModule(modulePrefix).getClass(iface).doc = idDoc; |
| } |
| result.getModule(modulePrefix).getClass(iface).addFile(sourceFile.fileName); |
| if (id.heritageClauses) { |
| id.heritageClauses.forEach(hc => { |
| hc.types.forEach(t => result.getModule(modulePrefix).getClass(iface).addInterits(t.expression.getText())); |
| }); |
| } |
| iface = ''; |
| break; |
| } |
| } |
| }; |
| |
| // Create the TS programm from the esnext definition - that definition includes |
| // all relevant definitions |
| let program = ts.createProgram(['node_modules/typescript/lib/lib.esnext.full.d.ts'], {}); |
| let checker = program.getTypeChecker(); |
| |
| program.getSourceFiles().forEach(sourceFile => { |
| if(/node_modules\/typescript\/lib\/.*\.ts$/.test(sourceFile.fileName)) { |
| ts.forEachChild(sourceFile, visit(sourceFile, '', '')); |
| } |
| }); |
| |
| /******************************************************************************* |
| * The extracted types are iterated and converted to JS source |
| ******************************************************************************/ |
| |
| function outputMember( outputName: string, memberInfo: MemberInfo, classes: ModuleInfo, ifaceName: string | undefined = undefined): string { |
| let result = ''; |
| result += '//Source: ' + memberInfo.file + '\n'; |
| result += '/**\n'; |
| result += memberInfo.doc; |
| result += '\n\n'; |
| for (const p of memberInfo.parameters) { |
| const pTypeInfo = toTypeName(p.type, classes, ifaceName); |
| result += '@param {'; |
| result += pTypeInfo.toJsDocDeclaration(); |
| result += '} '; |
| if (p.optional) { |
| result += '['; |
| } |
| result += p.name; |
| if (p.optional) { |
| result += ']'; |
| } |
| const doc = join(' - ', pTypeInfo.addDoc, p.doc); |
| if (doc) { |
| result += ' '; |
| result += doc; |
| } |
| result += '\n'; |
| } |
| result += '@returns {'; |
| |
| let returnInfo = toTypeName(memberInfo.returnType, classes, ifaceName); |
| result += returnInfo.toJsDocDeclaration(); |
| result += '}'; |
| if (returnInfo.addDoc && returnInfo.addDoc != returnInfo.toJsDocDeclaration()) { |
| result += ' '; |
| result += returnInfo.addDoc; |
| } |
| result += '\n'; |
| result += '**/\n'; |
| result += outputName + ' = ' + (memberInfo['callable'] ? 'function(' + (memberInfo.parameters.filter(p => !p.optional).map(p => p.name).join(', ')) + ') {}' : returnInfo.jsType) + ';\n\n'; |
| return result; |
| } |
| |
| function outputClassInfo(baseName: string, classInfo: ClassInfo, moduleInfo: ModuleInfo, modules: TypeData, staticDecl: boolean, ifaceName: string): string { |
| let result = ''; |
| classInfo.properties.forEach((memberInfo, method) => { |
| const outputName = baseName + method; |
| result += outputMember(outputName, memberInfo, moduleInfo, ifaceName); |
| }); |
| |
| classInfo.inherits.forEach(ancestor => { |
| |
| if(moduleInfo.classes.has(ancestor)) { |
| result += outputClassInfo(baseName, moduleInfo.classes.get(ancestor)!, moduleInfo, modules, staticDecl, ifaceName); |
| } else if (modules.modules.has('') && modules.getModule('').classes.has(ancestor)) { |
| result += outputClassInfo(baseName, modules.getModule('').getClass(ancestor), modules.getModule(''), modules, staticDecl, ifaceName); |
| } else { |
| process.stderr.write('Ancestor not found: ' + ancestor + ' for ' + baseName + '\n'); |
| } |
| }); |
| return result; |
| } |
| |
| /** |
| * Filter the output by only outputting type originating from the subset |
| * defined in this function. Definitions that are not targetted at either core |
| * js or the web related. |
| */ |
| function doOutput(sourceFiles: string[]): string[] { |
| const result: string[] = []; |
| for(const sourceFile of sourceFiles) { |
| if(/\/typescript\/lib\/lib\.es(\d+|next)\..*d.ts/.test(sourceFile) && result.indexOf('core') < 0) { |
| result.push('core'); |
| } else if(/\/typescript\/lib\/lib\.dom\..*d.ts/.test(sourceFile) && result.indexOf('dom') < 0) { |
| result.push('dom'); |
| } else if(/\/typescript\/lib\/lib\.webworker\..*d.ts/.test(sourceFile) && result.indexOf('dom') < 0) { |
| result.push('dom'); |
| } |
| } |
| return result; |
| } |
| |
| const modulesCreated: string[] = []; |
| const objectsCreated: string[] = []; |
| |
| fs.rmdirSync('out', {recursive: true}); |
| fs.mkdirSync('out'); |
| fs.mkdirSync('out/core'); |
| fs.mkdirSync('out/dom'); |
| |
| result.modules.forEach( |
| (moduleInfo, module) => { |
| |
| if(module !== '' && modulesCreated.indexOf(module) < 0) { |
| const sources: string[] = []; |
| moduleInfo.classes.forEach((classInfo, className) => { |
| classInfo.file.forEach(sourceFile => { |
| if(sources.indexOf(sourceFile) < 0) { |
| sources.push(sourceFile); |
| } |
| }); |
| }); |
| moduleInfo.functions.forEach(memberInfo => { |
| if (sources.indexOf(memberInfo.file) < 0) { |
| sources.push(memberInfo.file); |
| } |
| }); |
| moduleInfo.variables.forEach(memberInfo => { |
| if (sources.indexOf(memberInfo.file) < 0) { |
| sources.push(memberInfo.file); |
| } |
| }); |
| |
| modulesCreated.push(module); |
| |
| const targets = doOutput(sources); |
| if(targets.length == 1) { |
| fs.appendFileSync('out/' + targets[0] + '/' + module + '._.js', module + ' = function() {};\n\n', {encoding: 'utf-8'}); |
| } else { |
| throw 'Module in multiple areas: ' + module; |
| } |
| } |
| |
| moduleInfo.variables.forEach((memberInfo, memberName) => { |
| if(moduleInfo.classes.has(memberName)) { |
| return; |
| } |
| let name = memberName; |
| if(module === '' && name.startsWith('.')) { |
| name = name.substring(1); |
| } |
| const targets = doOutput([memberInfo.file]); |
| if(targets.length > 0) { |
| fs.appendFileSync('out/' + targets[0] + '/' + module + '._.js', outputMember(module + name, memberInfo, moduleInfo)); |
| } |
| }); |
| |
| moduleInfo.functions.forEach((memberInfo, memberName) => { |
| let name = memberName; |
| if(module === '' && name.startsWith('.')) { |
| name = name.substring(1); |
| } |
| const targets = doOutput([memberInfo.file]); |
| if(targets.length > 0) { |
| fs.appendFileSync('out/' + targets[0] + '/' + module + '._.js', outputMember(module + name, memberInfo, moduleInfo)); |
| } |
| }); |
| |
| moduleInfo.classes.forEach((classInfo, iface) => { |
| let targets = doOutput(classInfo.file); |
| if(targets.length == 0) { |
| return; |
| } else if (targets.length > 1) { |
| console.log('Class in multiple areas: ' + iface); |
| if(targets.indexOf('core') >= 0) { |
| targets = ['core']; |
| } |
| } |
| let ifaceName = iface; |
| if (iface.endsWith('Constructor')) { |
| ifaceName = iface.substring(0, iface.length - 11); |
| } |
| let targetFile; |
| if(module === '') { |
| targetFile = 'out/' + targets[0] + '/_.' + ifaceName + '.js'; |
| } else { |
| targetFile = 'out/' + targets[0] + '/' + module + '.' + (ifaceName === '' ? '_' : ifaceName) + '.js'; |
| } |
| const qualifiedIfaceName = (module === '' ? '' : (module + '.')) + ifaceName; |
| if(ifaceName != '' && qualifiedIfaceName.trim() !== '' && objectsCreated.indexOf(qualifiedIfaceName) < 0) { |
| let result = ''; |
| const constructorInfos = moduleInfo.classes.get(ifaceName)!.constructorInfo |
| .filter(ci => doOutput([ci.file])) |
| .sort((a, b) => b.parameters.length - a.parameters.length); |
| if (constructorInfos.length > 0) { |
| const constructorInfo = constructorInfos[0]; |
| result += '//Source: ' + constructorInfo.file + '\n'; |
| result += '/**\n'; |
| if(moduleInfo.classes.has(ifaceName) && moduleInfo.classes.get(ifaceName)!.doc) { |
| result += moduleInfo.classes.get(ifaceName)!.doc; |
| } |
| result += '\n'; |
| if(moduleInfo.classes.has(ifaceName + 'Constructor') && moduleInfo.classes.get(ifaceName + 'Constructor')!.doc) { |
| result += moduleInfo.classes.get(ifaceName + 'Constructor')!.doc; |
| } |
| result += '\n'; |
| |
| for(const ci of constructorInfos) { |
| let nonOptional: number; |
| for(nonOptional = 0; nonOptional < ci.parameters.length; nonOptional++) { |
| if(ci.parameters[nonOptional].optional) { |
| break; |
| } |
| } |
| for(let i = nonOptional; i <= ci.parameters.length; i++) { |
| result += '@example new ' + qualifiedIfaceName + '('; |
| for(let j = 0; j < i; j++) { |
| if(j != 0) { |
| result += ', '; |
| } |
| result += ci.parameters[j].name; |
| result += ': '; |
| const paramType = toTypeName(ci.parameters[j].type, moduleInfo, qualifiedIfaceName); |
| result += paramType.addDoc ? paramType.addDoc : paramType.toJsDocDeclaration(); |
| } |
| result += ')\n'; |
| } |
| } |
| |
| result += '\n'; |
| |
| for (const p of constructorInfo.parameters) { |
| const pTypeInfo = toTypeName(p.type, moduleInfo, qualifiedIfaceName); |
| result += '@param {'; |
| result += pTypeInfo.toJsDocDeclaration(); |
| result += '} '; |
| if (p.optional) { |
| result += '['; |
| } |
| result += p.name; |
| if (p.optional) { |
| result += ']'; |
| } |
| const doc = join(' - ', pTypeInfo.addDoc, p.doc); |
| if (doc) { |
| result += ' '; |
| result += doc; |
| } |
| result += '\n'; |
| } |
| |
| result += '@returns {' + qualifiedIfaceName + '}\n'; |
| result += '**/\n'; |
| result += qualifiedIfaceName + ' = function(' + (constructorInfo.parameters.filter(p => !p.optional).map(p => p.name).join(', ')) + ') {};\n\n'; |
| } else { |
| result += '/**\n'; |
| if(moduleInfo.classes.has(ifaceName) && moduleInfo.classes.get(ifaceName)!.doc) { |
| result += moduleInfo.classes.get(ifaceName)!.doc; |
| } |
| result += '\n'; |
| if(moduleInfo.classes.has(ifaceName + 'Constructor') && moduleInfo.classes.get(ifaceName + 'Constructor')!.doc) { |
| result += moduleInfo.classes.get(ifaceName + 'Constructor')!.doc; |
| } |
| result += '\n'; |
| result += '@returns {' + qualifiedIfaceName + '}\n'; |
| result += '*/\n'; |
| result += qualifiedIfaceName + ' = function() {};\n\n'; |
| } |
| fs.appendFileSync(targetFile, result, {encoding: 'utf-8'}); |
| objectsCreated.push(qualifiedIfaceName); |
| } |
| const staticDecl = iface.endsWith('Constructor') || iface === 'Math'; |
| let baseName = |
| (module === '' ? '' : (module + '.')) |
| + (ifaceName === '' ? '' : (ifaceName + '.')) |
| + (staticDecl ? '' : 'prototype.'); |
| baseName = baseName.substring(0, baseName.length - 1); |
| |
| fs.appendFileSync(targetFile, outputClassInfo(baseName, classInfo, moduleInfo, result, staticDecl, ifaceName), {encoding: 'utf-8'}); |
| }) |
| } |
| ); |
| |
| /******************************************************************************* |
| * Bundle the generated JS sources into the final corestubs.zip file |
| ******************************************************************************/ |
| |
| for (const subdir of ['core', 'dom']) { |
| let dirent: fs.Dirent | null; |
| let zip = new JSZip(); |
| let dir = zip.folder('jsstubs'); |
| |
| const outDir = fs.opendirSync('out/' + subdir); |
| while ((dirent = outDir.readSync()) != null) { |
| const buffer = fs.readFileSync('out/' + subdir + '/' + dirent.name); |
| dir!.file(dirent.name, buffer); |
| } |
| outDir.closeSync(); |
| |
| zip |
| .generateNodeStream({ streamFiles: true, compression: 'DEFLATE' }) |
| .pipe(fs.createWriteStream('out/' + subdir + '.zip')) |
| .on('finish', function() { |
| console.log('out/' + subdir + '.zip written.'); |
| }); |
| } |
