import*astsfrom"typescript";functioncompile(fileNames: string[],options: ts.CompilerOptions): void{letprogram=ts.createProgram(fileNames,options);letemitResult=program.emit();letallDiagnostics=ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);allDiagnostics.forEach(diagnostic=>{if(diagnostic.file){let{ line, character }=ts.getLineAndCharacterOfPosition(diagnostic.file,diagnostic.start!);letmessage=ts.flattenDiagnosticMessageText(diagnostic.messageText,"\n");console.log(`${diagnostic.file.fileName} (${line+1},${character+1}): ${message}`);}else{console.log(ts.flattenDiagnosticMessageText(diagnostic.messageText,"\n"));}});letexitCode=emitResult.emitSkipped ? 1 : 0;console.log(`Process exiting with code '${exitCode}'.`);process.exit(exitCode);}compile(process.argv.slice(2),{noEmitOnError: true,noImplicitAny: true,target: ts.ScriptTarget.ES5,module: ts.ModuleKind.CommonJS});

import*astsfrom"typescript";constsource="let x: string = 'string'";letresult=ts.transpileModule(source,{compilerOptions: {module: ts.ModuleKind.CommonJS}});console.log(JSON.stringify(result));

import*astsfrom"typescript";functioncompile(fileNames: string[],options: ts.CompilerOptions): void{// Create a Program with an in-memory emitconstcreatedFiles={}consthost=ts.createCompilerHost(options);host.writeFile=(fileName: string,contents: string)=>createdFiles[fileName]=contents// Prepare and emit the d.ts filesconstprogram=ts.createProgram(fileNames,options,host);program.emit();// Loop through all the input filesfileNames.forEach(file=>{console.log("### JavaScript\n")console.log(host.readFile(file))console.log("### Type Definition\n")constdts=file.replace(".js",".d.ts")console.log(createdFiles[dts])})}// Run the compilercompile(process.argv.slice(2),{allowJs: true,declaration: true,emitDeclarationOnly: true,});

import*astsfrom"typescript";/** * Prints out particular nodes from a source file *  * @param file a path to a file * @param identifiers top level identifiers available */functionextract(file: string,identifiers: string[]): void{// Create a Program to represent the project, then pull out the// source file to parse its AST.letprogram=ts.createProgram([file],{allowJs: true});constsourceFile=program.getSourceFile(file);// To print the AST, we'll use TypeScript's printerconstprinter=ts.createPrinter({newLine: ts.NewLineKind.LineFeed});// To give constructive error messages, keep track of found and un-found identifiersconstunfoundNodes=[],foundNodes=[];// Loop through the root AST nodes of the filets.forEachChild(sourceFile,node=>{letname="";// This is an incomplete set of AST nodes which could have a top level identifier// it's left to you to expand this list, which you can do by using// https://ts-ast-viewer.com/ to see the AST of a file then use the same patterns// as belowif(ts.isFunctionDeclaration(node)){name=node.name.text;// Hide the method body when printingnode.body=undefined;}elseif(ts.isVariableStatement(node)){name=node.declarationList.declarations[0].name.getText(sourceFile);}elseif(ts.isInterfaceDeclaration(node)){name=node.name.text}constcontainer=identifiers.includes(name) ? foundNodes : unfoundNodes;container.push([name,node]);});// Either print the found nodes, or offer a list of what identifiers were foundif(!foundNodes.length){console.log(`Could not find any of ${identifiers.join(", ")} in ${file}, found: ${unfoundNodes.filter(f=>f[0]).map(f=>f[0]).join(", ")}.`);process.exitCode=1;}else{foundNodes.map(f=>{const[name,node]=f;console.log("### "+name+"\n");console.log(printer.printNode(ts.EmitHint.Unspecified,node,sourceFile))+"\n";});}}// Run the extract function with the script's argumentsextract(process.argv[2],process.argv.slice(3));

import{readFileSync}from"fs";import*astsfrom"typescript";exportfunctiondelint(sourceFile: ts.SourceFile){delintNode(sourceFile);functiondelintNode(node: ts.Node){switch(node.kind){casets.SyntaxKind.ForStatement: casets.SyntaxKind.ForInStatement: casets.SyntaxKind.WhileStatement: casets.SyntaxKind.DoStatement: if((nodeasts.IterationStatement).statement.kind!==ts.SyntaxKind.Block){report(node,'A looping statement\'s contents should be wrapped in a block body.');}break;casets.SyntaxKind.IfStatement: constifStatement=nodeasts.IfStatement;if(ifStatement.thenStatement.kind!==ts.SyntaxKind.Block){report(ifStatement.thenStatement,'An if statement\'s contents should be wrapped in a block body.');}if(ifStatement.elseStatement&&ifStatement.elseStatement.kind!==ts.SyntaxKind.Block&&ifStatement.elseStatement.kind!==ts.SyntaxKind.IfStatement){report(ifStatement.elseStatement,'An else statement\'s contents should be wrapped in a block body.');}break;casets.SyntaxKind.BinaryExpression: constop=(nodeasts.BinaryExpression).operatorToken.kind;if(op===ts.SyntaxKind.EqualsEqualsToken||op===ts.SyntaxKind.ExclamationEqualsToken){report(node,'Use \'===\' and \'!==\'.');}break;}ts.forEachChild(node,delintNode);}functionreport(node: ts.Node,message: string){const{ line, character }=sourceFile.getLineAndCharacterOfPosition(node.getStart());console.log(`${sourceFile.fileName} (${line+1},${character+1}): ${message}`);}}constfileNames=process.argv.slice(2);fileNames.forEach(fileName=>{// Parse a fileconstsourceFile=ts.createSourceFile(fileName,readFileSync(fileName).toString(),ts.ScriptTarget.ES2015,/*setParentNodes */true);// delint itdelint(sourceFile);});

importts= require("typescript");constformatHost: ts.FormatDiagnosticsHost={getCanonicalFileName: path=>path,getCurrentDirectory: ts.sys.getCurrentDirectory,getNewLine: ()=>ts.sys.newLine};functionwatchMain(){constconfigPath=ts.findConfigFile(/*searchPath*/"./",ts.sys.fileExists,"tsconfig.json");if(!configPath){thrownewError("Could not find a valid 'tsconfig.json'.");}// TypeScript can use several different program creation "strategies":// * ts.createEmitAndSemanticDiagnosticsBuilderProgram,// * ts.createSemanticDiagnosticsBuilderProgram// * ts.createAbstractBuilder// The first two produce "builder programs". These use an incremental strategy// to only re-check and emit files whose contents may have changed, or whose// dependencies may have changes which may impact change the result of prior// type-check and emit.// The last uses an ordinary program which does a full type check after every// change.// Between `createEmitAndSemanticDiagnosticsBuilderProgram` and// `createSemanticDiagnosticsBuilderProgram`, the only difference is emit.// For pure type-checking scenarios, or when another tool/process handles emit,// using `createSemanticDiagnosticsBuilderProgram` may be more desirable.constcreateProgram=ts.createSemanticDiagnosticsBuilderProgram;// Note that there is another overload for `createWatchCompilerHost` that takes// a set of root files.consthost=ts.createWatchCompilerHost(configPath,{},ts.sys,createProgram,reportDiagnostic,reportWatchStatusChanged);// You can technically override any given hook on the host, though you probably// don't need to.// Note that we're assuming `origCreateProgram` and `origPostProgramCreate`// doesn't use `this` at all.constorigCreateProgram=host.createProgram;host.createProgram=(rootNames: ReadonlyArray<string>,options,host,oldProgram)=>{console.log("** We're about to create the program! **");returnorigCreateProgram(rootNames,options,host,oldProgram);};constorigPostProgramCreate=host.afterProgramCreate;host.afterProgramCreate=program=>{console.log("** We finished making the program! **");origPostProgramCreate!(program);};// `createWatchProgram` creates an initial program, watches files, and updates// the program over time.ts.createWatchProgram(host);}functionreportDiagnostic(diagnostic: ts.Diagnostic){console.error("Error",diagnostic.code,":",ts.flattenDiagnosticMessageText(diagnostic.messageText,formatHost.getNewLine()));}/** * Prints a diagnostic every time the watch status changes. * This is mainly for messages like "Starting compilation" or "Compilation completed". */functionreportWatchStatusChanged(diagnostic: ts.Diagnostic){console.info(ts.formatDiagnostic(diagnostic,formatHost));}watchMain();

import*asfsfrom"fs";import*astsfrom"typescript";functionwatch(rootFileNames: string[],options: ts.CompilerOptions){constfiles: ts.MapLike<{version: number}>={};// initialize the list of filesrootFileNames.forEach(fileName=>{files[fileName]={version: 0};});// Create the language service host to allow the LS to communicate with the hostconstservicesHost: ts.LanguageServiceHost={getScriptFileNames: ()=>rootFileNames,getScriptVersion: fileName=>files[fileName]&&files[fileName].version.toString(),getScriptSnapshot: fileName=>{if(!fs.existsSync(fileName)){returnundefined;}returnts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());},getCurrentDirectory: ()=>process.cwd(),getCompilationSettings: ()=>options,getDefaultLibFileName: options=>ts.getDefaultLibFilePath(options),fileExists: ts.sys.fileExists,readFile: ts.sys.readFile,readDirectory: ts.sys.readDirectory,directoryExists: ts.sys.directoryExists,getDirectories: ts.sys.getDirectories,};// Create the language service filesconstservices=ts.createLanguageService(servicesHost,ts.createDocumentRegistry());// Now let's watch the filesrootFileNames.forEach(fileName=>{// First time around, emit all filesemitFile(fileName);// Add a watch on the file to handle next changefs.watchFile(fileName,{persistent: true,interval: 250},(curr,prev)=>{// Check timestampif(+curr.mtime<=+prev.mtime){return;}// Update the version to signal a change in the filefiles[fileName].version++;// write the changes to diskemitFile(fileName);});});functionemitFile(fileName: string){letoutput=services.getEmitOutput(fileName);if(!output.emitSkipped){console.log(`Emitting ${fileName}`);}else{console.log(`Emitting ${fileName} failed`);logErrors(fileName);}output.outputFiles.forEach(o=>{fs.writeFileSync(o.name,o.text,"utf8");});}functionlogErrors(fileName: string){letallDiagnostics=services.getCompilerOptionsDiagnostics().concat(services.getSyntacticDiagnostics(fileName)).concat(services.getSemanticDiagnostics(fileName));allDiagnostics.forEach(diagnostic=>{letmessage=ts.flattenDiagnosticMessageText(diagnostic.messageText,"\n");if(diagnostic.file){let{ line, character }=diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start!);console.log(` Error ${diagnostic.file.fileName} (${line+1},${character+1}): ${message}`);}else{console.log(` Error: ${message}`);}});}}// Initialize files constituting the program as all .ts files in the current directoryconstcurrentDirectoryFiles=fs.readdirSync(process.cwd()).filter(fileName=>fileName.length>=3&&fileName.substr(fileName.length-3,3)===".ts");// Start the watcherwatch(currentDirectoryFiles,{module: ts.ModuleKind.CommonJS});

import*astsfrom"typescript";import*aspathfrom"path";functioncreateCompilerHost(options: ts.CompilerOptions,moduleSearchLocations: string[]): ts.CompilerHost{return{ getSourceFile,getDefaultLibFileName: ()=>"lib.d.ts",writeFile: (fileName,content)=>ts.sys.writeFile(fileName,content),getCurrentDirectory: ()=>ts.sys.getCurrentDirectory(),getDirectories: path=>ts.sys.getDirectories(path),getCanonicalFileName: fileName=>ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),getNewLine: ()=>ts.sys.newLine,useCaseSensitiveFileNames: ()=>ts.sys.useCaseSensitiveFileNames, fileExists, readFile, resolveModuleNames };functionfileExists(fileName: string): boolean{returnts.sys.fileExists(fileName);}functionreadFile(fileName: string): string|undefined{returnts.sys.readFile(fileName);}functiongetSourceFile(fileName: string,languageVersion: ts.ScriptTarget,onError?: (message: string)=>void){constsourceText=ts.sys.readFile(fileName);returnsourceText!==undefined ? ts.createSourceFile(fileName,sourceText,languageVersion) : undefined;}functionresolveModuleNames(moduleNames: string[],containingFile: string): ts.ResolvedModule[]{constresolvedModules: ts.ResolvedModule[]=[];for(constmoduleNameofmoduleNames){// try to use standard resolutionletresult=ts.resolveModuleName(moduleName,containingFile,options,{ fileExists, readFile });if(result.resolvedModule){resolvedModules.push(result.resolvedModule);}else{// check fallback locations, for simplicity assume that module at location// should be represented by '.d.ts' filefor(constlocationofmoduleSearchLocations){constmodulePath=path.join(location,moduleName+".d.ts");if(fileExists(modulePath)){resolvedModules.push({resolvedFileName: modulePath});}}}}returnresolvedModules;}}functioncompile(sourceFiles: string[],moduleSearchLocations: string[]): void{constoptions: ts.CompilerOptions={module: ts.ModuleKind.AMD,target: ts.ScriptTarget.ES5};consthost=createCompilerHost(options,moduleSearchLocations);constprogram=ts.createProgram(sourceFiles,options,host);/// do something with program...}

importts= require("typescript");functionmakeFactorialFunction(){constfunctionName=ts.factory.createIdentifier("factorial");constparamName=ts.factory.createIdentifier("n");constparameter=ts.factory.createParameterDeclaration(/*decorators*/undefined,/*modifiers*/undefined,/*dotDotDotToken*/undefined,paramName);constcondition=ts.factory.createBinaryExpression(paramName,ts.SyntaxKind.LessThanEqualsToken,ts.factory.createNumericLiteral(1));constifBody=ts.factory.createBlock([ts.factory.createReturnStatement(ts.factory.createNumericLiteral(1))],/*multiline*/true);constdecrementedArg=ts.factory.createBinaryExpression(paramName,ts.SyntaxKind.MinusToken,ts.factory.createNumericLiteral(1));constrecurse=ts.factory.createBinaryExpression(paramName,ts.SyntaxKind.AsteriskToken,ts.factory.createCallExpression(functionName,/*typeArgs*/undefined,[decrementedArg]));conststatements=[ts.factory.createIfStatement(condition,ifBody),ts.factory.createReturnStatement(recurse)];returnts.factory.createFunctionDeclaration(/*decorators*/undefined,/*modifiers*/[ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],/*asteriskToken*/undefined,functionName,/*typeParameters*/undefined,[parameter],/*returnType*/ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),ts.factory.createBlock(statements,/*multiline*/true));}constresultFile=ts.createSourceFile("someFileName.ts","",ts.ScriptTarget.Latest,/*setParentNodes*/false,ts.ScriptKind.TS);constprinter=ts.createPrinter({newLine: ts.NewLineKind.LineFeed});constresult=printer.printNode(ts.EmitHint.Unspecified,makeFactorialFunction(),resultFile);console.log(result);

functiongreet(){console.log("Hello, world!");}

import*astsfrom"typescript";import*asfsfrom"fs";interfaceDocEntry{name?: string;fileName?: string;documentation?: string;type?: string;constructors?: DocEntry[];parameters?: DocEntry[];returnType?: string;}/** Generate documentation for all classes in a set of .ts files */functiongenerateDocumentation(fileNames: string[],options: ts.CompilerOptions): void{// Build a program using the set of root file names in fileNamesletprogram=ts.createProgram(fileNames,options);// Get the checker, we will use it to find more about classesletchecker=program.getTypeChecker();letoutput: DocEntry[]=[];// Visit every sourceFile in the programfor(constsourceFileofprogram.getSourceFiles()){if(!sourceFile.isDeclarationFile){// Walk the tree to search for classests.forEachChild(sourceFile,visit);}}// print out the docfs.writeFileSync("classes.json",JSON.stringify(output,undefined,4));return;/** visit nodes finding exported classes */functionvisit(node: ts.Node){// Only consider exported nodesif(!isNodeExported(node)){return;}if(ts.isClassDeclaration(node)&&node.name){// This is a top level class, get its symbolletsymbol=checker.getSymbolAtLocation(node.name);if(symbol){output.push(serializeClass(symbol));}// No need to walk any further, class expressions/inner declarations// cannot be exported}elseif(ts.isModuleDeclaration(node)){// This is a namespace, visit its childrents.forEachChild(node,visit);}}/** Serialize a symbol into a json object */functionserializeSymbol(symbol: ts.Symbol): DocEntry{return{name: symbol.getName(),documentation: ts.displayPartsToString(symbol.getDocumentationComment(checker)),type: checker.typeToString(checker.getTypeOfSymbolAtLocation(symbol,symbol.valueDeclaration!))};}/** Serialize a class symbol information */functionserializeClass(symbol: ts.Symbol){letdetails=serializeSymbol(symbol);// Get the construct signaturesletconstructorType=checker.getTypeOfSymbolAtLocation(symbol,symbol.valueDeclaration!);details.constructors=constructorType.getConstructSignatures().map(serializeSignature);returndetails;}/** Serialize a signature (call or construct) */functionserializeSignature(signature: ts.Signature){return{parameters: signature.parameters.map(serializeSymbol),returnType: checker.typeToString(signature.getReturnType()),documentation: ts.displayPartsToString(signature.getDocumentationComment(checker))};}/** True if this is visible outside this file, false otherwise */functionisNodeExported(node: ts.Node): boolean{return((ts.getCombinedModifierFlags(nodeasts.Declaration)&ts.ModifierFlags.Export)!==0||(!!node.parent&&node.parent.kind===ts.SyntaxKind.SourceFile));}}generateDocumentation(process.argv.slice(2),{target: ts.ScriptTarget.ES5,module: ts.ModuleKind.CommonJS});

/** * Documentation for C */classC{/** * constructor documentation * @param a my parameter documentation * @param b another parameter documentation */constructor(a: string,b: C){}}