brighterscript 0.42.0 → 0.45.0

package/dist/Program.d.ts

@@ -4,12 +4,13 @@ import type { BsConfig } from './BsConfig';
 import { Scope } from './Scope';
 import { BrsFile } from './files/BrsFile';
 import { XmlFile } from './files/XmlFile';
-import type { BsDiagnostic, File, FileReference, FileObj, BscFile, SemanticToken } from './interfaces';
+import type { BsDiagnostic, File, 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 {
     pathAbsolute: string;
     source: string;
@@ -24,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
@@ -116,8 +113,9 @@ export declare class Program {
     /**
      * Determine if the specified file is loaded in this program right now.
      * @param filePath
+     * @param normalizePath should the provided path be normalized before use
      */
-    hasFile(filePath: string): boolean;
+    hasFile(filePath: string, normalizePath?: boolean): boolean;
     getPkgPath(...args: any[]): any;
     /**
      * roku filesystem is case INsensitive, so find the scope by key case insensitive
@@ -132,19 +130,42 @@ export declare class Program {
      * Find the scope for the specified component
      */
     getComponentScope(componentName: string): XmlScope;
+    /**
+     * Update internal maps with this file reference
+     */
+    private assignFile;
+    /**
+     * Remove this file from internal maps
+     */
+    private unassignFile;
     /**
      * Load a file into the program. If that file already exists, it is replaced.
      * If file contents are provided, those are used, Otherwise, the file is loaded from the file system
-     * @param relativePath the file path relative to the root dir
+     * @param srcPath the file path relative to the root dir
      * @param fileContents the file contents
+     * @deprecated use `setFile` instead
      */
-    addOrReplaceFile<T extends BscFile>(relativePath: string, fileContents: string): T;
+    addOrReplaceFile<T extends BscFile>(srcPath: string, fileContents: string): T;
     /**
      * Load a file into the program. If that file already exists, it is replaced.
      * @param fileEntry an object that specifies src and dest for the file.
      * @param fileContents the file contents. If not provided, the file will be loaded from disk
+     * @deprecated use `setFile` instead
      */
     addOrReplaceFile<T extends BscFile>(fileEntry: FileObj, fileContents: string): T;
+    /**
+     * Load a file into the program. If that file already exists, it is replaced.
+     * If file contents are provided, those are used, Otherwise, the file is loaded from the file system
+     * @param srcDestOrPkgPath the absolute path, the pkg path (i.e. `pkg:/path/to/file.brs`), or the destPath (i.e. `path/to/file.brs` relative to `pkg:/`)
+     * @param fileContents the file contents
+     */
+    setFile<T extends BscFile>(srcDestOrPkgPath: string, fileContents: string): T;
+    /**
+     * Load a file into the program. If that file already exists, it is replaced.
+     * @param fileEntry an object that specifies src and dest for the file.
+     * @param fileContents the file contents. If not provided, the file will be loaded from disk
+     */
+    setFile<T extends BscFile>(fileEntry: FileObj, fileContents: string): T;
     /**
      * Ensure source scope is created.
      * Note: automatically called internally, and no-op if it exists already.
@@ -155,28 +176,33 @@ export declare class Program {
      * Roku is a case insensitive file system. It is an error to have multiple files
      * with the same path with only case being different.
      * @param pathAbsolute
+     * @deprecated use `getFile` instead, which auto-detects the path type
      */
     getFileByPathAbsolute<T extends BrsFile | XmlFile>(pathAbsolute: string): T;
     /**
      * Get a list of files for the given (platform-normalized) pkgPath array.
      * Missing files are just ignored.
+     * @deprecated use `getFiles` instead, which auto-detects the path types
      */
     getFilesByPkgPaths<T extends BscFile[]>(pkgPaths: string[]): T;
     /**
      * Get a file with the specified (platform-normalized) pkg path.
      * If not found, return undefined
+     * @deprecated use `getFile` instead, which auto-detects the path type
      */
     getFileByPkgPath<T extends BscFile>(pkgPath: string): T;
     /**
      * Remove a set of files from the program
-     * @param absolutePaths
+     * @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(absolutePaths: string[]): void;
+    removeFiles(srcPaths: string[], normalizePath?: boolean): void;
     /**
      * Remove a file from the program
-     * @param pathAbsolute
+     * @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(pathAbsolute: string): void;
+    removeFile(filePath: string, normalizePath?: boolean): void;
     /**
      * Traverse the entire project, and validate all scopes
      * @param force - if true, then all scopes are force to validate, even if they aren't marked as dirty
@@ -190,25 +216,35 @@ export declare class Program {
      * Determine if the given file is included in at least one scope in this program
      */
     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 pathAbsolute
+     * @param filePath can be a srcPath or a destPath
+     * @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
      */
-    private getFile;
+    getFile<T extends BscFile>(filePath: string, normalizePath?: boolean): T;
     /**
      * Get a list of all scopes the file is loaded into
      * @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>[];
     /**
      * Find all available completion items at the given position
-     * @param pathAbsolute
-     * @param lineIndex
-     * @param columnIndex
+     * @param filePath can be a srcPath or a destPath
+     * @param position the position (line & column) where completions should be found
      */
-    getCompletions(pathAbsolute: string, position: Position): CompletionItem[];
+    getCompletions(filePath: string, position: Position): CompletionItem[];
     /**
      * Goes through each file and builds a list of workspace symbols for the program. Used by LanguageServer's onWorkspaceSymbol functionality
      */
@@ -240,19 +276,19 @@ export declare class Program {
      * Transpile a single file and get the result as a string.
      * This does not write anything to the file system.
      */
-    getTranspiledFileContents(pathAbsolute: string): {
-        pathAbsolute: 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): 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): BscFile[];
     /**
@@ -262,3 +298,10 @@ export declare class Program {
     private _manifest;
     dispose(): void;
 }
+export interface FileTranspileResult {
+    pathAbsolute: string;
+    pkgPath: string;
+    code: string;
+    map: SourceMapGenerator;
+    typedef: string;
+}

package/dist/Program.js

@@ -20,8 +20,8 @@ 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 AstEditor_1 = require("./astUtils/AstEditor");
 const startOfSourcePkgPath = `source${path.sep}`;
@@ -87,11 +87,11 @@ class Program {
      */
     get bslibPkgPath() {
         //if there's an aliased (preferred) version of bslib from roku_modules loaded into the program, use that
-        if (this.getFileByPkgPath(bslibAliasedRokuModulesPkgPath)) {
+        if (this.getFile(bslibAliasedRokuModulesPkgPath)) {
             return bslibAliasedRokuModulesPkgPath;
             //if there's a non-aliased version of bslib from roku_modules, use that
         }
-        else if (this.getFileByPkgPath(bslibNonAliasedRokuModulesPkgPath)) {
+        else if (this.getFile(bslibNonAliasedRokuModulesPkgPath)) {
             return bslibNonAliasedRokuModulesPkgPath;
             //default to the embedded version
         }
@@ -220,10 +220,10 @@ class Program {
     /**
      * Determine if the specified file is loaded in this program right now.
      * @param filePath
+     * @param normalizePath should the provided path be normalized before use
      */
-    hasFile(filePath) {
-        filePath = (0, util_1.standardizePath) `${filePath}`;
-        return this.files[filePath] !== undefined;
+    hasFile(filePath, normalizePath = true) {
+        return !!this.getFile(filePath, normalizePath);
     }
     getPkgPath(...args) {
         throw new Error('Not implemented');
@@ -255,8 +255,27 @@ class Program {
         var _a;
         return (_a = this.getComponent(componentName)) === null || _a === void 0 ? void 0 : _a.scope;
     }
+    /**
+     * Update internal maps with this file reference
+     */
+    assignFile(file) {
+        this.files[file.pathAbsolute.toLowerCase()] = file;
+        this.pkgMap[file.pkgPath.toLowerCase()] = file;
+        return file;
+    }
+    /**
+     * Remove this file from internal maps
+     */
+    unassignFile(file) {
+        delete this.files[file.pathAbsolute.toLowerCase()];
+        delete this.pkgMap[file.pkgPath.toLowerCase()];
+        return file;
+    }
     addOrReplaceFile(fileParam, fileContents) {
-        assert.ok(fileParam, 'fileEntry is required');
+        return this.setFile(fileParam, fileContents);
+    }
+    setFile(fileParam, fileContents) {
+        assert.ok(fileParam, 'fileParam is required');
         let srcPath;
         let pkgPath;
         if (typeof fileParam === 'string') {
@@ -267,7 +286,7 @@ class Program {
             srcPath = (0, util_1.standardizePath) `${fileParam.src}`;
             pkgPath = (0, util_1.standardizePath) `${fileParam.dest}`;
         }
-        let file = this.logger.time(Logger_1.LogLevel.debug, ['Program.addOrReplaceFile()', chalk_1.default.green(srcPath)], () => {
+        let file = this.logger.time(Logger_1.LogLevel.debug, ['Program.setFile()', chalk_1.default.green(srcPath)], () => {
             assert.ok(srcPath, 'fileEntry.src is required');
             assert.ok(pkgPath, 'fileEntry.dest is required');
             //if the file is already loaded, remove it
@@ -277,15 +296,13 @@ class Program {
             let fileExtension = path.extname(srcPath).toLowerCase();
             let file;
             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(startOfSourcePkgPath)) {
                     this.createSourceScope();
                     this.dependencyGraph.addDependency('scope:source', brsFile.dependencyGraphKey);
                 }
-                //add the file to the program
-                this.files[srcPath] = brsFile;
-                this.pkgMap[brsFile.pkgPath.toLowerCase()] = brsFile;
                 let sourceObj = {
                     pathAbsolute: srcPath,
                     source: fileContents
@@ -294,19 +311,18 @@ class Program {
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
                     brsFile.parse(sourceObj.source);
                 });
+                //notify plugins that this file has finished parsing
+                this.plugins.emit('afterFileParse', brsFile);
                 file = brsFile;
                 brsFile.attachDependencyGraph(this.dependencyGraph);
-                this.plugins.emit('afterFileValidate', brsFile);
             }
             else if (
             //is xml file
             fileExtension === '.xml' &&
                 //resides in the components folder (Roku will only parse xml files in the components folder)
                 pkgPath.toLowerCase().startsWith(util_1.util.pathSepNormalize(`components/`))) {
-                let xmlFile = new XmlFile_1.XmlFile(srcPath, pkgPath, this);
                 //add the file to the program
-                this.files[srcPath] = xmlFile;
-                this.pkgMap[xmlFile.pkgPath.toLowerCase()] = xmlFile;
+                const xmlFile = this.assignFile(new XmlFile_1.XmlFile(srcPath, pkgPath, this));
                 let sourceObj = {
                     pathAbsolute: srcPath,
                     source: fileContents
@@ -315,13 +331,14 @@ class Program {
                 this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
                     xmlFile.parse(sourceObj.source);
                 });
+                //notify plugins that this file has finished parsing
+                this.plugins.emit('afterFileParse', 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('afterFileValidate', xmlFile);
             }
             else {
                 //TODO do we actually need to implement this? Figure out how to handle img paths
@@ -352,6 +369,7 @@ class Program {
      * Roku is a case insensitive file system. It is an error to have multiple files
      * with the same path with only case being different.
      * @param pathAbsolute
+     * @deprecated use `getFile` instead, which auto-detects the path type
      */
     getFileByPathAbsolute(pathAbsolute) {
         pathAbsolute = (0, util_1.standardizePath) `${pathAbsolute}`;
@@ -364,6 +382,7 @@ class Program {
     /**
      * Get a list of files for the given (platform-normalized) pkgPath array.
      * Missing files are just ignored.
+     * @deprecated use `getFiles` instead, which auto-detects the path types
      */
     getFilesByPkgPaths(pkgPaths) {
         return pkgPaths
@@ -373,29 +392,29 @@ class Program {
     /**
      * Get a file with the specified (platform-normalized) pkg path.
      * If not found, return undefined
+     * @deprecated use `getFile` instead, which auto-detects the path type
      */
     getFileByPkgPath(pkgPath) {
         return this.pkgMap[pkgPath.toLowerCase()];
     }
     /**
      * Remove a set of files from the program
-     * @param absolutePaths
+     * @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(absolutePaths) {
-        for (let pathAbsolute of absolutePaths) {
-            this.removeFile(pathAbsolute);
+    removeFiles(srcPaths, normalizePath = true) {
+        for (let srcPath of srcPaths) {
+            this.removeFile(srcPath, normalizePath);
         }
     }
     /**
      * Remove a file from the program
-     * @param pathAbsolute
+     * @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(pathAbsolute) {
-        this.logger.debug('Program.removeFile()', pathAbsolute);
-        if (!path.isAbsolute(pathAbsolute)) {
-            throw new Error(`Path must be absolute: "${pathAbsolute}"`);
-        }
-        let file = this.getFile(pathAbsolute);
+    removeFile(filePath, normalizePath = true) {
+        this.logger.debug('Program.removeFile()', filePath);
+        let file = this.getFile(filePath, normalizePath);
         if (file) {
             this.plugins.emit('beforeFileDispose', file);
             //if there is a scope named the same as this file's path, remove it (i.e. xml scopes)
@@ -409,8 +428,7 @@ class Program {
                 this.plugins.emit('afterScopeDispose', scope);
             }
             //remove the file from the program
-            delete this.files[file.pathAbsolute];
-            delete this.pkgMap[file.pkgPath.toLowerCase()];
+            this.unassignFile(file);
             this.dependencyGraph.remove(file.dependencyGraphKey);
             //if this is a pkg:/source file, notify the `source` scope that it has changed
             if (file.pkgPath.startsWith(startOfSourcePkgPath)) {
@@ -429,23 +447,40 @@ class Program {
      */
     validate() {
         this.logger.time(Logger_1.LogLevel.log, ['Validating project'], () => {
+            var _a;
             this.diagnostics = [];
             this.plugins.emit('beforeProgramValidate', this);
-            this.logger.time(Logger_1.LogLevel.info, ['Validate all scopes'], () => {
-                for (let scopeName in this.scopes) {
-                    let scope = this.scopes[scopeName];
-                    scope.validate();
-                }
-            });
-            //find any files NOT loaded into a scope
-            for (let filePath in this.files) {
-                let file = this.files[filePath];
+            //validate every file
+            for (const file of Object.values(this.files)) {
+                //find any files NOT loaded into a scope
                 if (!this.fileIsIncludedInAnyScope(file)) {
                     this.logger.debug('Program.validate(): fileNotReferenced by any scope', () => chalk_1.default.green(file === null || file === void 0 ? void 0 : file.pkgPath));
                     //the file is not loaded in any scope
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.fileNotReferencedByAnyOtherFile()), { file: file, range: util_1.util.createRange(0, 0, 0, Number.MAX_VALUE) }));
                 }
+                //for every unvalidated file, validate it
+                if (!file.isValidated) {
+                    this.plugins.emit('beforeFileValidate', {
+                        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;
+                    this.plugins.emit('afterFileValidate', file);
+                }
             }
+            this.logger.time(Logger_1.LogLevel.info, ['Validate all scopes'], () => {
+                for (let scopeName in this.scopes) {
+                    let scope = this.scopes[scopeName];
+                    scope.validate();
+                }
+            });
             this.detectDuplicateComponentNames();
             this.plugins.emit('afterProgramValidate', this);
         });
@@ -494,13 +529,31 @@ 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 pathAbsolute
+     * @param filePath can be a srcPath or a destPath
+     * @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
      */
-    getFile(pathAbsolute) {
-        pathAbsolute = (0, util_1.standardizePath) `${pathAbsolute}`;
-        return this.files[pathAbsolute];
+    getFile(filePath, normalizePath = true) {
+        if (typeof filePath !== 'string') {
+            return undefined;
+        }
+        else if (path.isAbsolute(filePath)) {
+            return this.files[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
+        }
+        else {
+            return this.pkgMap[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
+        }
     }
     /**
      * Get a list of all scopes the file is loaded into
@@ -516,6 +569,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();
@@ -574,17 +638,16 @@ class Program {
     }
     /**
      * Find all available completion items at the given position
-     * @param pathAbsolute
-     * @param lineIndex
-     * @param columnIndex
+     * @param filePath can be a srcPath or a destPath
+     * @param position the position (line & column) where completions should be found
      */
-    getCompletions(pathAbsolute, position) {
-        let file = this.getFile(pathAbsolute);
+    getCompletions(filePath, position) {
+        let file = this.getFile(filePath);
         if (!file) {
             return [];
         }
         let result = [];
-        if ((0, reflection_1.isBrsFile)(file) && file.isPositionNextToTokenKind(position, lexer_1.TokenKind.Callfunc)) {
+        if ((0, reflection_1.isBrsFile)(file) && file.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) => (0, reflection_1.isXmlScope)(s))) {
                 let fileLinks = this.getStatementsForXmlFile(scope);
@@ -652,7 +715,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
@@ -725,7 +789,7 @@ class Program {
                 let myClass = file.getClassFromMReference(position, file.getTokenAt(position), functionScope);
                 if (myClass) {
                     for (let scope of this.getScopesForFile(myClass.file)) {
-                        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) => (0, reflection_1.isClassMethodStatement)(i.item))) {
                             let sigHelp = statement.file.getSignatureHelpForStatement(statement.item);
@@ -796,12 +860,12 @@ class Program {
             //try to get sig help based on the name
             index = position.character;
             let currentToken = file.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.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('.');
@@ -970,9 +1034,49 @@ class Program {
      * This does not write anything to the file system.
      */
     getTranspiledFileContents(pathAbsolute) {
-        let file = this.getFile(pathAbsolute);
-        let result = file.transpile();
-        return Object.assign(Object.assign({}, result), { pathAbsolute: file.pathAbsolute, pkgPath: file.pkgPath });
+        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,
+            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,
+            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 {
+            pathAbsolute: file.pathAbsolute,
+            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
@@ -996,8 +1100,7 @@ class Program {
             outputPath = (0, util_1.standardizePath) `${stagingFolderPath}/${outputPath}`;
             return {
                 file: file,
-                outputPath: outputPath,
-                editor: new AstEditor_1.AstEditor()
+                outputPath: outputPath
             };
         });
         this.plugins.emit('beforeProgramTranspile', this, entries);
@@ -1006,32 +1109,22 @@ class Program {
             if ((0, reflection_1.isBrsFile)(entry.file) && entry.file.isTypedef) {
                 return;
             }
-            this.plugins.emit('beforeFileTranspile', entry);
             const { file, outputPath } = entry;
-            //if we have any edits, assume the file needs to be transpiled
-            if (entry.editor.hasChanges) {
-                //use the `editor` because it'll track the previous value for us and revert later on
-                entry.editor.setProperty(file, 'needsTranspiled', true);
-            }
-            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.pathAbsolute}". 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 ((0, 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', entry);
-            //undo all `editor` edits that may have been applied to this file.
-            entry.editor.undoAll();
         });
         //if there's no bslib file already loaded into the program, copy it to the staging directory
         if (!this.getFileByPkgPath(bslibAliasedRokuModulesPkgPath) && !this.getFileByPkgPath((0, util_1.standardizePath) `source/bslib.brs`)) {
@@ -1059,7 +1152,7 @@ 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 = [];