brighterscript 1.0.0-alpha.10 → 1.0.0-alpha.14

package/dist/Program.d.ts

@@ -4,11 +4,13 @@ import type { BsConfig } from './BsConfig';
 import { Scope } from './Scope';
 import { BrsFile } from './files/BrsFile';
 import { XmlFile } from './files/XmlFile';
-import type { BsDiagnostic, FileReference, FileObj, BscFile, SemanticToken } from './interfaces';
+import type { BsDiagnostic, FileReference, FileObj, BscFile, SemanticToken, FileLink } from './interfaces';
 import { XmlScope } from './XmlScope';
 import { Logger } from './Logger';
+import type { ManifestValue } from './preprocessor/Manifest';
 import PluginInterface from './PluginInterface';
 import type { FunctionStatement, Statement } from './parser/Statement';
+import type { SourceMapGenerator } from 'source-map';
 export interface SourceObj {
     srcPath: string;
     source: string;
@@ -23,10 +25,6 @@ export interface SignatureInfoObj {
     key: string;
     signature: SignatureInformation;
 }
-export interface FileLink<T> {
-    item: T;
-    file: BrsFile;
-}
 export declare class Program {
     /**
      * The root directory for this program
@@ -77,7 +75,7 @@ export declare class Program {
     /**
      * Get a copy of the list of files currently loaded in the program
      */
-    getFiles(): (BrsFile | XmlFile)[];
+    getAllFiles(): BscFile[];
     private scopes;
     protected addScope(scope: Scope): void;
     /**
@@ -112,7 +110,7 @@ export declare class Program {
      * Get a list of all files that are included in the project but are not referenced
      * by any scope in the program.
      */
-    getUnreferencedFiles(): (BrsFile | XmlFile)[];
+    getUnreferencedFiles(): BscFile[];
     /**
      * Get the list of errors for the entire program. It's calculated on the fly
      * by walking through every file, so call this sparingly.
@@ -166,14 +164,14 @@ export declare class Program {
     createSourceScope(): void;
     /**
      * Remove a set of files from the program
-     * @param srcPaths
+     * @param filePaths can be an array of srcPath or destPath strings
+     * @param normalizePath should this function repair and standardize the filePaths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
      */
-    removeFiles(srcPaths: string[]): void;
+    removeFiles(filePaths: string[], normalizePath?: boolean): void;
     /**
      * Remove a file from the program
      * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
-
      */
     removeFile(filePath: string, normalizePath?: boolean): void;
     /**
@@ -195,6 +193,12 @@ export declare class Program {
      * Determine at least one scope has the file
      */
     private fileIsIncludedInAnyScope;
+    /**
+     * Get the files for a list of filePaths
+     * @param filePaths can be an array of srcPath or a destPath strings
+     * @param normalizePath should this function repair and standardize the paths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
+     */
+    getFiles<T extends BscFile>(filePaths: string[], normalizePath?: boolean): T[];
     /**
      * Get the file at the given path
      * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
@@ -206,6 +210,10 @@ export declare class Program {
      * @param file
      */
     getScopesForFile(file: XmlFile | BrsFile): Scope[];
+    /**
+     * Get the first found scope for a file.
+     */
+    getFirstScopeForFile(file: XmlFile | BrsFile): Scope;
     getStatementsByName(name: string, originFile: BrsFile, namespaceName?: string): FileLink<Statement>[];
     getStatementsForXmlFile(scope: XmlScope, filterName?: string): FileLink<FunctionStatement>[];
     /**
@@ -255,25 +263,32 @@ export declare class Program {
      * This does not write anything to the file system.
      * @param srcPath The absolute path to the source file on disk
      */
-    getTranspiledFileContents(srcPath: string): {
-        srcPath: string;
-        pkgPath: string;
-        code: string;
-        map: import("source-map").SourceMapGenerator;
-    };
+    getTranspiledFileContents(pathAbsolute: string): FileTranspileResult;
+    /**
+     * Internal function used to transpile files.
+     * This does not write anything to the file system
+     */
+    private _getTranspiledFileContents;
     transpile(fileEntries: FileObj[], stagingFolderPath: string): Promise<void>;
     /**
      * Find a list of files in the program that have a function with the given name (case INsensitive)
      */
-    findFilesForFunction(functionName: string): (BrsFile | XmlFile)[];
+    findFilesForFunction(functionName: string): BscFile[];
     /**
-     * Find a list of files in the program that have a function with the given name (case INsensitive)
+     * Find a list of files in the program that have a class with the given name (case INsensitive)
      */
-    findFilesForClass(className: string): (BrsFile | XmlFile)[];
+    findFilesForClass(className: string): BscFile[];
     /**
      * Get a map of the manifest information
      */
-    getManifest(): Map<string, string | number | boolean>;
+    getManifest(): Map<string, ManifestValue>;
     private _manifest;
     dispose(): void;
 }
+export interface FileTranspileResult {
+    srcPath: string;
+    pkgPath: string;
+    code: string;
+    map: SourceMapGenerator;
+    typedef: string;
+}

package/dist/Program.js

@@ -20,10 +20,11 @@ const Manifest_1 = require("./preprocessor/Manifest");
 const vscode_uri_1 = require("vscode-uri");
 const PluginInterface_1 = require("./PluginInterface");
 const reflection_1 = require("./astUtils/reflection");
-const parser_1 = require("./parser");
-const lexer_1 = require("./lexer");
+const Parser_1 = require("./parser/Parser");
+const TokenKind_1 = require("./lexer/TokenKind");
 const BscPlugin_1 = require("./bscPlugin/BscPlugin");
 const roku_deploy_1 = require("roku-deploy");
+const AstEditor_1 = require("./astUtils/AstEditor");
 const bslibNonAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/rokucommunity_bslib/bslib.brs`;
 const bslibAliasedRokuModulesPkgPath = `pkg:/source/roku_modules/bslib/bslib.brs`;
 class Program {
@@ -112,7 +113,7 @@ class Program {
     /**
      * Get a copy of the list of files currently loaded in the program
      */
-    getFiles() {
+    getAllFiles() {
         return Object.values(this.files);
     }
     addScope(scope) {
@@ -266,6 +267,7 @@ class Program {
     assignFile(file) {
         this.files[file.srcPath.toLowerCase()] = file;
         this.pkgMap[file.pkgPath.toLowerCase()] = file;
+        return file;
     }
     /**
      * Remove this file from internal maps
@@ -273,6 +275,7 @@ class Program {
     unassignFile(file) {
         delete this.files[file.srcPath.toLowerCase()];
         delete this.pkgMap[file.pkgPath.toLowerCase()];
+        return file;
     }
     setFile(fileParam, fileContents) {
         assert.ok(fileParam, 'fileParam is required');
@@ -282,7 +285,7 @@ class Program {
             //is a pkg path
             if (fileParam.startsWith('pkg:/')) {
                 //srcPath is the pkgPath relative to the rootDir
-                srcPath = util_1.standardizePath `${this.options.rootDir}/${fileParam.substring(5)}`;
+                srcPath = (0, util_1.standardizePath) `${this.options.rootDir}/${fileParam.substring(5)}`;
                 pkgPath = fileParam;
                 //is a srcPath (absolute path to src file location)
             }
@@ -293,13 +296,13 @@ class Program {
                 //is destPath (path relative to rootDir and `pkg:/`)
             }
             else {
-                srcPath = util_1.standardizePath `${this.options.rootDir}/${fileParam}`;
+                srcPath = (0, util_1.standardizePath) `${this.options.rootDir}/${fileParam}`;
                 pkgPath = util_1.util.sanitizePkgPath(fileParam);
             }
             //is a FileObj
         }
         else {
-            srcPath = util_1.standardizePath `${fileParam.src}`;
+            srcPath = (0, util_1.standardizePath) `${fileParam.src}`;
             pkgPath = util_1.util.sanitizePkgPath(fileParam.dest);
         }
         const lowerPkgPath = pkgPath.toLowerCase();
@@ -318,7 +321,8 @@ class Program {
                 source: fileContents
             };
             if (fileExtension === '.brs' || fileExtension === '.bs') {
-                let brsFile = new BrsFile_1.BrsFile(srcPath, pkgPath, this);
+                //add the file to the program
+                const brsFile = this.assignFile(new BrsFile_1.BrsFile(srcPath, pkgPath, this));
                 //add file to the `source` dependency list
                 if (brsFile.pkgPath.startsWith('pkg:/source/')) {
                     this.createSourceScope();
@@ -330,35 +334,36 @@ class Program {
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
                     brsFile.parse(beforeFileParseEvent.source);
                 });
-                file = brsFile;
-                brsFile.attachDependencyGraph(this.dependencyGraph);
+                //notify plugins that this file has finished parsing
                 this.plugins.emit('afterFileParse', {
                     program: this,
                     file: brsFile
                 });
+                file = brsFile;
+                brsFile.attachDependencyGraph(this.dependencyGraph);
             }
             else if (
             //is xml file
             fileExtension === '.xml' &&
                 //resides in the components folder (Roku will only parse xml files in the components folder)
                 lowerPkgPath.startsWith('pkg:/components/')) {
-                let xmlFile = new XmlFile_1.XmlFile(srcPath, pkgPath, this);
-                this.assignFile(xmlFile);
                 //add the file to the program
+                const xmlFile = this.assignFile(new XmlFile_1.XmlFile(srcPath, pkgPath, this));
                 this.plugins.emit('beforeFileParse', beforeFileParseEvent);
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
                     xmlFile.parse(beforeFileParseEvent.source);
                 });
+                //notify plugins that this file has finished parsing
+                this.plugins.emit('afterFileParse', {
+                    program: this,
+                    file: xmlFile
+                });
                 file = xmlFile;
                 //create a new scope for this xml file
                 let scope = new XmlScope_1.XmlScope(xmlFile, this);
                 this.addScope(scope);
                 //register this compoent now that we have parsed it and know its component name
                 this.registerComponent(xmlFile, scope);
-                this.plugins.emit('afterFileParse', {
-                    program: this,
-                    file: xmlFile
-                });
             }
             else {
                 //TODO do we actually need to implement this? Figure out how to handle img paths
@@ -385,18 +390,18 @@ class Program {
     }
     /**
      * Remove a set of files from the program
-     * @param srcPaths
+     * @param filePaths can be an array of srcPath or destPath strings
+     * @param normalizePath should this function repair and standardize the filePaths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
      */
-    removeFiles(srcPaths) {
-        for (let srcPath of srcPaths) {
-            this.removeFile(srcPath);
+    removeFiles(filePaths, normalizePath = true) {
+        for (let filiePath of filePaths) {
+            this.removeFile(filiePath, normalizePath);
         }
     }
     /**
      * Remove a file from the program
      * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
-
      */
     removeFile(filePath, normalizePath = true) {
         this.logger.debug('Program.removeFile()', filePath);
@@ -430,7 +435,7 @@ class Program {
                 this.dependencyGraph.removeDependency('scope:source', file.dependencyGraphKey);
             }
             //if this is a component, remove it from our components map
-            if (reflection_1.isXmlFile(file)) {
+            if ((0, reflection_1.isXmlFile)(file)) {
                 this.unregisterComponent(file);
             }
             this.plugins.emit('afterFileDispose', {
@@ -483,6 +488,11 @@ class Program {
                         program: this,
                         file: file
                     });
+                    //emit an event to allow plugins to contribute to the file validation process
+                    this.plugins.emit('onFileValidate', {
+                        program: this,
+                        file: file
+                    });
                     //call file.validate() IF the file has that function defined
                     (_a = file.validate) === null || _a === void 0 ? void 0 : _a.call(file);
                     file.isValidated = true;
@@ -524,7 +534,7 @@ class Program {
         for (const key in this.files) {
             const file = this.files[key];
             //if this is an XmlFile, and it has a valid `componentName` property
-            if (reflection_1.isXmlFile(file)) {
+            if ((0, reflection_1.isXmlFile)(file)) {
                 const componentNameLower = (_a = file.componentName) === null || _a === void 0 ? void 0 : _a.text.toLowerCase();
                 if (componentNameLower) {
                     if (!componentsByName.has(componentNameLower)) {
@@ -562,6 +572,16 @@ class Program {
         }
         return false;
     }
+    /**
+     * Get the files for a list of filePaths
+     * @param filePaths can be an array of srcPath or a destPath strings
+     * @param normalizePath should this function repair and standardize the paths? Passing false should have a performance boost if you can guarantee your paths are already sanitized
+     */
+    getFiles(filePaths, normalizePath = true) {
+        return filePaths
+            .map(filePath => this.getFile(filePath, normalizePath))
+            .filter(file => file !== undefined);
+    }
     /**
      * Get the file at the given path
      * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
@@ -592,6 +612,17 @@ class Program {
         }
         return result;
     }
+    /**
+     * Get the first found scope for a file.
+     */
+    getFirstScopeForFile(file) {
+        for (let key in this.scopes) {
+            let scope = this.scopes[key];
+            if (scope.hasFile(file)) {
+                return scope;
+            }
+        }
+    }
     getStatementsByName(name, originFile, namespaceName) {
         var _a, _b;
         let results = new Map();
@@ -601,7 +632,7 @@ class Program {
         //look through all files in scope for matches
         for (const scope of this.getScopesForFile(originFile)) {
             for (const file of scope.getAllFiles()) {
-                if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
+                if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
                     continue;
                 }
                 filesSearched.add(file);
@@ -624,9 +655,9 @@ class Program {
         //get all function names for the xml file and parents
         let funcNames = new Set();
         let currentScope = scope;
-        while (reflection_1.isXmlScope(currentScope)) {
+        while ((0, reflection_1.isXmlScope)(currentScope)) {
             for (let member of (_b = (_a = currentScope.xmlFile.ast.component) === null || _a === void 0 ? void 0 : _a.interfaceMembers) !== null && _b !== void 0 ? _b : []) {
-                if (reflection_1.isSGInterfaceFunction(member)) {
+                if ((0, reflection_1.isSGInterfaceFunction)(member)) {
                     const name = member.name;
                     if (!filterName || name === filterName) {
                         funcNames.add(name);
@@ -637,7 +668,7 @@ class Program {
         }
         //look through all files in scope for matches
         for (const file of scope.getOwnFiles()) {
-            if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
+            if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
                 continue;
             }
             filesSearched.add(file);
@@ -663,9 +694,9 @@ class Program {
             return [];
         }
         let result = [];
-        if (reflection_1.isBrsFile(file) && file.parser.isPositionNextToTokenKind(position, lexer_1.TokenKind.Callfunc)) {
+        if ((0, reflection_1.isBrsFile)(file) && file.parser.isPositionNextToTokenKind(position, TokenKind_1.TokenKind.Callfunc)) {
             // is next to a @. callfunc invocation - must be an interface method
-            for (const scope of this.getScopes().filter((s) => reflection_1.isXmlScope(s))) {
+            for (const scope of this.getScopes().filter((s) => (0, reflection_1.isXmlScope)(s))) {
                 let fileLinks = this.getStatementsForXmlFile(scope);
                 for (let fileLink of fileLinks) {
                     result.push(scope.createCompletionFromFunctionStatement(fileLink.item));
@@ -703,7 +734,7 @@ class Program {
         const result = [];
         for (const key in this.files) {
             const file = this.files[key];
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 result.push(...file.getWorkspaceSymbols());
             }
         }
@@ -719,7 +750,7 @@ class Program {
         if (!file) {
             return [];
         }
-        if (reflection_1.isBrsFile(file)) {
+        if ((0, reflection_1.isBrsFile)(file)) {
             return file.getDefinition(position);
         }
         else {
@@ -740,7 +771,8 @@ class Program {
         if (!file) {
             return null;
         }
-        return Promise.resolve(file.getHover(position));
+        const hover = file.getHover(position);
+        return Promise.resolve(hover);
     }
     /**
      * Compute code actions for the given file and range
@@ -788,7 +820,7 @@ class Program {
     getSignatureHelp(filepath, position) {
         var _a;
         let file = this.getFile(filepath);
-        if (!file || !reflection_1.isBrsFile(file)) {
+        if (!file || !(0, reflection_1.isBrsFile)(file)) {
             return [];
         }
         const results = new Map();
@@ -816,9 +848,9 @@ class Program {
                     scope.linkSymbolTable();
                     let myClass = file.getClassFromToken(currentToken, functionExpression, scope);
                     if (myClass) {
-                        let classes = scope.getClassHierarchy(myClass.item.getName(parser_1.ParseMode.BrighterScript).toLowerCase());
+                        let classes = scope.getClassHierarchy(myClass.item.getName(Parser_1.ParseMode.BrighterScript).toLowerCase());
                         //and anything from any class in scope to a non m class
-                        for (let statement of [...classes].filter((i) => reflection_1.isClassMethodStatement(i.item))) {
+                        for (let statement of [...classes].filter((i) => (0, reflection_1.isClassMethodStatement)(i.item))) {
                             let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
                             if (sigHelp && !results.has[sigHelp.key]) {
                                 results.set(sigHelp.key, sigHelp);
@@ -848,7 +880,7 @@ class Program {
             }
         }
         else if (identifierInfo.statementType === '@.') {
-            for (const scope of this.getScopes().filter((s) => reflection_1.isXmlScope(s))) {
+            for (const scope of this.getScopes().filter((s) => (0, reflection_1.isXmlScope)(s))) {
                 let fileLinks = this.getStatementsForXmlFile(scope, identifierInfo.name);
                 for (let fileLink of fileLinks) {
                     let sigHelp = fileLink.file.getSignatureHelpForStatement(fileLink.item);
@@ -888,12 +920,12 @@ class Program {
             //try to get sig help based on the name
             index = position.character;
             let currentToken = file.parser.getTokenAt(position);
-            if (currentToken && currentToken.kind !== lexer_1.TokenKind.Comment) {
-                name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
+            if (currentToken && currentToken.kind !== TokenKind_1.TokenKind.Comment) {
+                name = file.getPartialVariableName(currentToken, [TokenKind_1.TokenKind.New]);
                 if (!name) {
                     //try the previous token, incase we're on a bracket
                     currentToken = file.parser.getPreviousToken(currentToken);
-                    name = file.getPartialVariableName(currentToken, [lexer_1.TokenKind.New]);
+                    name = file.getPartialVariableName(currentToken, [TokenKind_1.TokenKind.New]);
                 }
                 if (name === null || name === void 0 ? void 0 : name.indexOf('.')) {
                     let parts = name.split('.');
@@ -1063,21 +1095,63 @@ class Program {
      * This does not write anything to the file system.
      * @param srcPath The absolute path to the source file on disk
      */
-    getTranspiledFileContents(srcPath) {
-        let file = this.getFile(srcPath);
-        let result = file.transpile();
-        return Object.assign(Object.assign({}, result), { srcPath: file.srcPath, pkgPath: file.pkgPath });
+    getTranspiledFileContents(pathAbsolute) {
+        return this._getTranspiledFileContents(this.getFile(pathAbsolute));
+    }
+    /**
+     * Internal function used to transpile files.
+     * This does not write anything to the file system
+     */
+    _getTranspiledFileContents(file, outputPath) {
+        const editor = new AstEditor_1.AstEditor();
+        this.plugins.emit('beforeFileTranspile', {
+            file: file,
+            program: this,
+            outputPath: outputPath,
+            editor: editor
+        });
+        //if we have any edits, assume the file needs to be transpiled
+        if (editor.hasChanges) {
+            //use the `editor` because it'll track the previous value for us and revert later on
+            editor.setProperty(file, 'needsTranspiled', true);
+        }
+        //transpile the file
+        const result = file.transpile();
+        //generate the typedef if enabled
+        let typedef;
+        if ((0, reflection_1.isBrsFile)(file) && this.options.emitDefinitions) {
+            typedef = file.getTypedef();
+        }
+        const event = {
+            file: file,
+            program: this,
+            outputPath: outputPath,
+            editor: editor,
+            code: result.code,
+            map: result.map,
+            typedef: typedef
+        };
+        this.plugins.emit('afterFileTranspile', event);
+        //undo all `editor` edits that may have been applied to this file.
+        editor.undoAll();
+        return {
+            srcPath: file.srcPath,
+            pkgPath: file.pkgPath,
+            code: event.code,
+            map: event.map,
+            typedef: event.typedef
+        };
     }
     async transpile(fileEntries, stagingFolderPath) {
         // map fileEntries using their path as key to avoid excessive "find()" operations
         const mappedFileEntries = fileEntries.reduce((collection, entry) => {
-            collection[util_1.standardizePath `${entry.src}`] = entry;
+            collection[(0, util_1.standardizePath) `${entry.src}`] = entry;
             return collection;
         }, {});
         const entries = [];
         for (const key in this.files) {
             const file = this.files[key];
-            let filePathObj = mappedFileEntries[util_1.standardizePath `${file.srcPath}`];
+            let filePathObj = mappedFileEntries[(0, util_1.standardizePath) `${file.srcPath}`];
             if (!filePathObj) {
                 //this file has been added in-memory, from a plugin, for example
                 filePathObj = {
@@ -1093,10 +1167,12 @@ class Program {
                 //change any .bs file extension to .brs
                 .replace(/\.bs$/gi, '.brs');
             //prepend the staging folder path
-            outputPath = util_1.standardizePath `${stagingFolderPath}/${outputPath}`;
+            outputPath = (0, util_1.standardizePath) `${stagingFolderPath}/${outputPath}`;
             entries.push({
                 file: file,
-                outputPath: outputPath
+                program: this,
+                outputPath: outputPath,
+                editor: new AstEditor_1.AstEditor()
             });
         }
         this.plugins.emit('beforeProgramTranspile', {
@@ -1105,36 +1181,25 @@ class Program {
         });
         const promises = entries.map(async (entry) => {
             //skip transpiling typedef files
-            if (reflection_1.isBrsFile(entry.file) && entry.file.isTypedef) {
+            if ((0, reflection_1.isBrsFile)(entry.file) && entry.file.isTypedef) {
                 return;
             }
-            this.plugins.emit('beforeFileTranspile', {
-                program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
-            });
             const { file, outputPath } = entry;
-            const result = file.transpile();
+            const fileTranspileResult = this._getTranspiledFileContents(file, outputPath);
             //make sure the full dir path exists
             await fsExtra.ensureDir(path.dirname(outputPath));
             if (await fsExtra.pathExists(outputPath)) {
                 throw new Error(`Error while transpiling "${file.srcPath}". A file already exists at "${outputPath}" and will not be overwritten.`);
             }
-            const writeMapPromise = result.map ? fsExtra.writeFile(`${outputPath}.map`, result.map.toString()) : null;
+            const writeMapPromise = fileTranspileResult.map ? fsExtra.writeFile(`${outputPath}.map`, fileTranspileResult.map.toString()) : null;
             await Promise.all([
-                fsExtra.writeFile(outputPath, result.code),
+                fsExtra.writeFile(outputPath, fileTranspileResult.code),
                 writeMapPromise
             ]);
-            if (reflection_1.isBrsFile(file) && this.options.emitDefinitions) {
-                const typedef = file.getTypedef();
+            if (fileTranspileResult.typedef) {
                 const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
-                await fsExtra.writeFile(typedefPath, typedef);
+                await fsExtra.writeFile(typedefPath, fileTranspileResult.typedef);
             }
-            this.plugins.emit('afterFileTranspile', {
-                program: this,
-                file: entry.file,
-                outputPath: entry.outputPath
-            });
         });
         //if there's no bslib file already loaded into the program, copy it to the staging directory
         if (!this.getFile(bslibAliasedRokuModulesPkgPath) && !this.getFile(`pkg:/source/bslib.brs`)) {
@@ -1154,7 +1219,7 @@ class Program {
         const lowerFunctionName = functionName.toLowerCase();
         //find every file with this function defined
         for (const file of Object.values(this.files)) {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 //TODO handle namespace-relative function calls
                 //if the file has a function with this name
                 if (file.parser.references.functionStatementLookup.get(lowerFunctionName) !== undefined) {
@@ -1165,14 +1230,14 @@ class Program {
         return files;
     }
     /**
-     * Find a list of files in the program that have a function with the given name (case INsensitive)
+     * Find a list of files in the program that have a class with the given name (case INsensitive)
      */
     findFilesForClass(className) {
         const files = [];
         const lowerClassName = className.toLowerCase();
         //find every file with this class defined
         for (const file of Object.values(this.files)) {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 //TODO handle namespace-relative classes
                 //if the file has a function with this name
                 if (file.parser.references.classStatementLookup.get(lowerClassName) !== undefined) {
@@ -1194,7 +1259,7 @@ class Program {
             try {
                 //we only load this manifest once, so do it sync to improve speed downstream
                 contents = fsExtra.readFileSync(manifestPath, 'utf-8');
-                this._manifest = Manifest_1.parseManifest(contents);
+                this._manifest = (0, Manifest_1.parseManifest)(contents);
             }
             catch (err) {
                 this._manifest = new Map();