brighterscript 0.66.0-alpha.6 → 0.66.0-alpha.7

package/dist/Program.js

@@ -6,8 +6,6 @@ const fsExtra = require("fs-extra");
 const path = require("path");
 const Scope_1 = require("./Scope");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
-const BrsFile_1 = require("./files/BrsFile");
-const XmlFile_1 = require("./files/XmlFile");
 const util_1 = require("./util");
 const XmlScope_1 = require("./XmlScope");
 const DiagnosticFilterer_1 = require("./DiagnosticFilterer");
@@ -20,8 +18,7 @@ const vscode_uri_1 = require("vscode-uri");
 const PluginInterface_1 = require("./PluginInterface");
 const reflection_1 = require("./astUtils/reflection");
 const BscPlugin_1 = require("./bscPlugin/BscPlugin");
-const AstEditor_1 = require("./astUtils/AstEditor");
-const roku_deploy_1 = require("roku-deploy");
+const Editor_1 = require("./astUtils/Editor");
 const CallExpressionInfo_1 = require("./bscPlugin/CallExpressionInfo");
 const SignatureHelpUtil_1 = require("./bscPlugin/SignatureHelpUtil");
 const DiagnosticSeverityAdjuster_1 = require("./DiagnosticSeverityAdjuster");
@@ -36,11 +33,14 @@ const LongIntegerType_1 = require("./types/LongIntegerType");
 const ObjectType_1 = require("./types/ObjectType");
 const VoidType_1 = require("./types/VoidType");
 const FunctionType_1 = require("./types/FunctionType");
+const Factory_1 = require("./files/Factory");
+const ActionPipeline_1 = require("./ActionPipeline");
+const LazyFileData_1 = require("./files/LazyFileData");
+const roku_deploy_1 = require("roku-deploy");
 const roku_types_1 = require("./roku-types");
 const ComponentType_1 = require("./types/ComponentType");
 const types_1 = require("./types");
 const BuiltInInterfaceAdder_1 = require("./types/BuiltInInterfaceAdder");
-const startOfSourcePkgPath = `source${path.sep}`;
 const bslibNonAliasedRokuModulesPkgPath = (0, util_1.standardizePath) `source/roku_modules/rokucommunity_bslib/bslib.brs`;
 const bslibAliasedRokuModulesPkgPath = (0, util_1.standardizePath) `source/roku_modules/bslib/bslib.brs`;
 class Program {
@@ -50,6 +50,10 @@ class Program {
      */
     options, logger, plugins) {
         this.options = options;
+        /**
+         * An editor that plugins can use to modify program-level things during the build flow. Don't use this to edit files (they have their own `.editor`)
+         */
+        this.editor = new Editor_1.Editor();
         /**
          * A graph of all files and their dependencies.
          * For example:
@@ -68,7 +72,16 @@ class Program {
          * A map of every file loaded into this program, indexed by its original file location
          */
         this.files = {};
-        this.pkgMap = {};
+        /**
+         * A map of every file loaded into this program, indexed by its destPath
+         */
+        this.destMap = new Map();
+        /**
+         * Plugins can contribute multiple virtual files for a single physical file.
+         * This collection links the virtual files back to the physical file that produced them.
+         * The key is the standardized and lower-cased srcPath
+         */
+        this.fileClusters = new Map();
         this.scopes = {};
         /**
          * A map of every component currently loaded into the program, indexed by the component name.
@@ -81,6 +94,8 @@ class Program {
          * Keeps a set of all the components that need to have their types updated during the current validation cycle
          */
         this.componentSymbolsToUpdate = new Set();
+        this.getTranspiledFileContentsPipeline = new ActionPipeline_1.ActionPipeline();
+        this.buildPipeline = new ActionPipeline_1.ActionPipeline();
         this.options = util_1.util.normalizeConfig(options);
         this.logger = logger || new Logger_1.Logger(options.logLevel);
         this.plugins = plugins || new PluginInterface_1.default([], { logger: this.logger });
@@ -89,6 +104,7 @@ class Program {
         //normalize the root dir path
         this.options.rootDir = util_1.util.getRootDir(this.options);
         this.createGlobalScope();
+        this.fileFactory = new Factory_1.FileFactory(this);
     }
     createGlobalScope() {
         //create the 'global' scope
@@ -126,7 +142,7 @@ class Program {
             this.globalScope.symbolTable.addSymbol(nodeName, { description: nodeData.description }, nodeType, SymbolTable_1.SymbolTypeFlag.typetime);
         }
         else {
-            nodeType = this.globalScope.symbolTable.getSymbolType(nodeData.name, { flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            nodeType = this.globalScope.symbolTable.getSymbolType(nodeName, { flags: SymbolTable_1.SymbolTypeFlag.typetime });
         }
         return nodeType;
     }
@@ -182,7 +198,7 @@ class Program {
             //default to the embedded version
         }
         else {
-            return `source${path.sep}bslib.brs`;
+            return `${this.options.bslibDestinationDir}${path.sep}bslib.brs`;
         }
     }
     get bslibPrefix() {
@@ -203,7 +219,7 @@ class Program {
         var _a;
         if (componentName) {
             //return the first compoment in the list with this name
-            //(components are ordered in this list by pkgPath to ensure consistency)
+            //(components are ordered in this list by destPath to ensure consistency)
             return (_a = this.components[componentName.toLowerCase()]) === null || _a === void 0 ? void 0 : _a[0];
         }
         else {
@@ -223,8 +239,8 @@ class Program {
             scope: scope
         });
         this.components[key].sort((a, b) => {
-            const pathA = a.file.pkgPath.toLowerCase();
-            const pathB = b.file.pkgPath.toLowerCase();
+            const pathA = a.file.destPath.toLowerCase();
+            const pathB = b.file.destPath.toLowerCase();
             if (pathA < pathB) {
                 return -1;
             }
@@ -300,6 +316,7 @@ class Program {
             //attach (or re-attach) the dependencyGraph for every component whose position changed
             if (file.dependencyGraphIndex !== i) {
                 file.dependencyGraphIndex = i;
+                this.dependencyGraph.addOrReplace(file.dependencyGraphKey, file.dependencies);
                 file.attachDependencyGraph(this.dependencyGraph);
                 scope.attachDependencyGraph(this.dependencyGraph);
             }
@@ -336,7 +353,7 @@ class Program {
             //get the diagnostics from all unreferenced files
             let unreferencedFiles = this.getUnreferencedFiles();
             for (let file of unreferencedFiles) {
-                diagnostics.push(...file.getDiagnostics());
+                diagnostics.push(...file.diagnostics);
             }
             const filteredDiagnostics = this.logger.time(Logger_1.LogLevel.debug, ['filter diagnostics'], () => {
                 //filter out diagnostics based on our diagnostic filters
@@ -361,11 +378,9 @@ class Program {
     hasFile(filePath, normalizePath = true) {
         return !!this.getFile(filePath, normalizePath);
     }
-    getPkgPath(...args) {
-        throw new Error('Not implemented');
-    }
     /**
      * roku filesystem is case INsensitive, so find the scope by key case insensitive
+     * @param scopeName xml scope names are their `destPath`. Source scope is stored with the key `"source"`
      */
     getScopeByName(scopeName) {
         if (!scopeName) {
@@ -394,8 +409,14 @@ class Program {
      * Update internal maps with this file reference
      */
     assignFile(file) {
+        const fileAddEvent = {
+            file: file,
+            program: this
+        };
+        this.plugins.emit('beforeFileAdd', fileAddEvent);
         this.files[file.srcPath.toLowerCase()] = file;
-        this.pkgMap[file.pkgPath.toLowerCase()] = file;
+        this.destMap.set(file.destPath.toLowerCase(), file);
+        this.plugins.emit('afterFileAdd', fileAddEvent);
         return file;
     }
     /**
@@ -403,104 +424,102 @@ class Program {
      */
     unassignFile(file) {
         delete this.files[file.srcPath.toLowerCase()];
-        delete this.pkgMap[file.pkgPath.toLowerCase()];
+        this.destMap.delete(file.destPath.toLowerCase());
         return file;
     }
-    setFile(fileParam, fileContents) {
+    setFile(fileParam, fileData) {
         //normalize the file paths
-        const { srcPath, pkgPath } = this.getPaths(fileParam, this.options.rootDir);
+        const { srcPath, destPath } = this.getPaths(fileParam, this.options.rootDir);
         let file = this.logger.time(Logger_1.LogLevel.debug, ['Program.setFile()', chalk_1.default.green(srcPath)], () => {
+            var _a, _b, _c;
             //if the file is already loaded, remove it
             if (this.hasFile(srcPath)) {
                 this.removeFile(srcPath);
             }
-            let fileExtension = path.extname(srcPath).toLowerCase();
-            let file;
-            if (fileExtension === '.brs' || fileExtension === '.bs') {
-                //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);
-                }
-                let beforeFileParseEvent = {
-                    program: this,
-                    srcPath: srcPath,
-                    source: fileContents
-                };
-                this.plugins.emit('beforeFileParse', beforeFileParseEvent);
-                this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    brsFile.parse(beforeFileParseEvent.source);
-                });
-                //notify plugins that this file has finished parsing
-                this.plugins.emit('afterFileParse', {
-                    program: this,
-                    file: brsFile
-                });
-                file = brsFile;
-                brsFile.attachDependencyGraph(this.dependencyGraph);
+            const data = new LazyFileData_1.LazyFileData(fileData);
+            const event = new ProvideFileEventInternal(this, srcPath, destPath, data, this.fileFactory);
+            this.plugins.emit('beforeProvideFile', event);
+            this.plugins.emit('provideFile', event);
+            this.plugins.emit('afterProvideFile', event);
+            //if no files were provided, create a AssetFile to represent it.
+            if (event.files.length === 0) {
+                event.files.push(this.fileFactory.AssetFile({
+                    srcPath: event.srcPath,
+                    destPath: event.destPath,
+                    pkgPath: event.destPath,
+                    data: data
+                }));
             }
-            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/`))) {
-                //add the file to the program
-                const xmlFile = this.assignFile(new XmlFile_1.XmlFile(srcPath, pkgPath, this));
-                let event = {
-                    program: this,
-                    srcPath: srcPath,
-                    source: fileContents
-                };
-                this.plugins.emit('beforeFileParse', event);
-                this.logger.time(Logger_1.LogLevel.debug, ['parse', chalk_1.default.green(srcPath)], () => {
-                    xmlFile.parse(event.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 component now that we have parsed it and know its component name
-                this.registerComponent(xmlFile, scope);
-                //notify plugins that the scope is created and the component is registered
-                this.plugins.emit('afterScopeCreate', {
-                    program: this,
-                    scope: scope
-                });
+            //find the file instance for the srcPath that triggered this action.
+            const primaryFile = event.files.find(x => x.srcPath === srcPath);
+            if (!primaryFile) {
+                throw new Error(`No file provided for srcPath '${srcPath}'. Instead, received ${JSON.stringify(event.files.map(x => ({
+                    type: x.type,
+                    srcPath: x.srcPath,
+                    destPath: x.destPath
+                })))}`);
             }
-            else {
-                //TODO do we actually need to implement this? Figure out how to handle img paths
-                // let genericFile = this.files[srcPath] = <any>{
-                //     srcPath: srcPath,
-                //     pkgPath: pkgPath,
-                //     wasProcessed: true
-                // } as File;
-                // file = <any>genericFile;
+            //link the virtual files to the primary file
+            this.fileClusters.set((_a = primaryFile.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase(), event.files);
+            for (const file of event.files) {
+                file.srcPath = (0, util_1.standardizePath)(file.srcPath);
+                if (file.destPath) {
+                    file.destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.destPath, this.options.rootDir, '')}`;
+                }
+                if (file.pkgPath) {
+                    file.pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(file.pkgPath, this.options.rootDir, '')}`;
+                }
+                else {
+                    file.pkgPath = file.destPath;
+                }
+                file.excludeFromOutput = file.excludeFromOutput === true;
+                //set the dependencyGraph key for every file to its destPath
+                file.dependencyGraphKey = file.destPath.toLowerCase();
+                this.assignFile(file);
+                //register a callback anytime this file's dependencies change
+                if (typeof file.onDependenciesChanged === 'function') {
+                    (_b = file.disposables) !== null && _b !== void 0 ? _b : (file.disposables = []);
+                    file.disposables.push(this.dependencyGraph.onchange(file.dependencyGraphKey, file.onDependenciesChanged.bind(file)));
+                }
+                //register this file (and its dependencies) with the dependency graph
+                this.dependencyGraph.addOrReplace(file.dependencyGraphKey, (_c = file.dependencies) !== null && _c !== void 0 ? _c : []);
+                //if this is a `source` file, add it to the source scope's dependency list
+                if (this.isSourceBrsFile(file)) {
+                    this.createSourceScope();
+                    this.dependencyGraph.addDependency('scope:source', file.dependencyGraphKey);
+                }
+                //if this is an xml file in the components folder, register it as a component
+                if (this.isComponentsXmlFile(file)) {
+                    //create a new scope for this xml file
+                    let scope = new XmlScope_1.XmlScope(file, this);
+                    this.addScope(scope);
+                    //register this compoent now that we have parsed it and know its component name
+                    this.registerComponent(file, scope);
+                    //notify plugins that the scope is created and the component is registered
+                    this.plugins.emit('afterScopeCreate', {
+                        program: this,
+                        scope: scope
+                    });
+                }
             }
-            return file;
+            return primaryFile;
         });
         return file;
     }
     /**
-     * Given a srcPath, a pkgPath, or both, resolve whichever is missing, relative to rootDir.
+     * Given a srcPath, a destPath, or both, resolve whichever is missing, relative to rootDir.
      * @param fileParam an object representing file paths
      * @param rootDir must be a pre-normalized path
      */
     getPaths(fileParam, rootDir) {
         let srcPath;
-        let pkgPath;
+        let destPath;
         assert.ok(fileParam, 'fileParam is required');
-        //lift the srcPath and pkgPath vars from the incoming param
+        //lift the path vars from the incoming param
         if (typeof fileParam === 'string') {
             fileParam = this.removePkgPrefix(fileParam);
             srcPath = (0, util_1.standardizePath) `${path.resolve(rootDir, fileParam)}`;
-            pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
+            destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
         }
         else {
             let param = fileParam;
@@ -511,30 +530,30 @@ class Program {
                 srcPath = (0, util_1.standardizePath) `${param.srcPath}`;
             }
             if (param.dest) {
-                pkgPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.dest)}`;
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.dest)}`;
             }
             if (param.pkgPath) {
-                pkgPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.pkgPath)}`;
+                destPath = (0, util_1.standardizePath) `${this.removePkgPrefix(param.pkgPath)}`;
             }
         }
-        //if there's no srcPath, use the pkgPath to build an absolute srcPath
+        //if there's no srcPath, use the destPath to build an absolute srcPath
         if (!srcPath) {
-            srcPath = (0, util_1.standardizePath) `${rootDir}/${pkgPath}`;
+            srcPath = (0, util_1.standardizePath) `${rootDir}/${destPath}`;
         }
         //coerce srcPath to an absolute path
         if (!path.isAbsolute(srcPath)) {
             srcPath = util_1.util.standardizePath(srcPath);
         }
-        //if there's no pkgPath, compute relative path from rootDir
-        if (!pkgPath) {
-            pkgPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
+        //if destPath isn't set, compute it from the other paths
+        if (!destPath) {
+            destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
         }
         assert.ok(srcPath, 'fileEntry.src is required');
-        assert.ok(pkgPath, 'fileEntry.dest is required');
+        assert.ok(destPath, 'fileEntry.dest is required');
         return {
             srcPath: srcPath,
-            //remove leading slash from pkgPath
-            pkgPath: pkgPath.replace(/^[\/\\]+/, '')
+            //remove leading slash
+            destPath: destPath.replace(/^[\/\\]+/, '')
         };
     }
     /**
@@ -543,6 +562,18 @@ class Program {
     removePkgPrefix(path) {
         return path.replace(/^pkg:\//i, '');
     }
+    /**
+     * Is this file a .brs file found somewhere within the `pkg:/source/` folder?
+     */
+    isSourceBrsFile(file) {
+        return !!/^(pkg:\/)?source[\/\\]/.exec(file.destPath);
+    }
+    /**
+     * Is this file a .brs file found somewhere within the `pkg:/source/` folder?
+     */
+    isComponentsXmlFile(file) {
+        return (0, reflection_1.isXmlFile)(file) && !!/^(pkg:\/)?components[\/\\]/.exec(file.destPath);
+    }
     /**
      * Ensure source scope is created.
      * Note: automatically called internally, and no-op if it exists already.
@@ -570,46 +601,55 @@ class Program {
     }
     /**
      * Remove a file from the program
-     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
+     * @param filePath can be a srcPath, a destPath, or a destPath with leading `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) {
+        var _a, _b, _c, _d;
         this.logger.debug('Program.removeFile()', filePath);
-        let file = this.getFile(filePath, normalizePath);
-        if (file) {
-            const fileDisposeEvent = {
-                program: this,
-                file: file
-            };
-            this.plugins.emit('beforeFileDispose', fileDisposeEvent);
+        const paths = this.getPaths(filePath, this.options.rootDir);
+        //there can be one or more File entries for a single srcPath, so get all of them and remove them all
+        const files = (_b = this.fileClusters.get((_a = paths.srcPath) === null || _a === void 0 ? void 0 : _a.toLowerCase())) !== null && _b !== void 0 ? _b : [this.getFile(filePath, normalizePath)];
+        for (const file of files) {
+            //if a file has already been removed, nothing more needs to be done here
+            if (!file || !this.hasFile(file.srcPath)) {
+                continue;
+            }
+            const event = { file: file, program: this };
+            this.plugins.emit('beforeFileRemove', event);
             //if there is a scope named the same as this file's path, remove it (i.e. xml scopes)
-            let scope = this.scopes[file.pkgPath];
+            let scope = this.scopes[file.destPath];
             if (scope) {
                 const scopeDisposeEvent = {
                     program: this,
                     scope: scope
                 };
                 this.plugins.emit('beforeScopeDispose', scopeDisposeEvent);
+                this.plugins.emit('onScopeDispose', scopeDisposeEvent);
                 scope.dispose();
                 //notify dependencies of this scope that it has been removed
                 this.dependencyGraph.remove(scope.dependencyGraphKey);
-                delete this.scopes[file.pkgPath];
+                delete this.scopes[file.destPath];
                 this.plugins.emit('afterScopeDispose', scopeDisposeEvent);
             }
             //remove the file from the program
             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)) {
+            if (this.isSourceBrsFile(file)) {
                 this.dependencyGraph.removeDependency('scope:source', file.dependencyGraphKey);
             }
             //if this is a component, remove it from our components map
             if ((0, reflection_1.isXmlFile)(file)) {
                 this.unregisterComponent(file);
             }
+            //dispose any disposable things on the file
+            for (const disposable of (_c = file === null || file === void 0 ? void 0 : file.disposables) !== null && _c !== void 0 ? _c : []) {
+                disposable();
+            }
             //dispose file
-            file === null || file === void 0 ? void 0 : file.dispose();
-            this.plugins.emit('afterFileDispose', fileDisposeEvent);
+            (_d = file === null || file === void 0 ? void 0 : file.dispose) === null || _d === void 0 ? void 0 : _d.call(file);
+            this.plugins.emit('afterFileRemove', event);
         }
     }
     /**
@@ -622,6 +662,7 @@ class Program {
                 program: this
             };
             this.plugins.emit('beforeProgramValidate', programValidateEvent);
+            this.plugins.emit('onProgramValidate', programValidateEvent);
             //validate every file
             for (const file of Object.values(this.files)) {
                 //for every unvalidated file, validate it
@@ -706,12 +747,13 @@ class Program {
     getFile(filePath, normalizePath = true) {
         if (typeof filePath !== 'string') {
             return undefined;
+            //is the path absolute (or the `virtual:` prefix)
         }
-        else if (path.isAbsolute(filePath)) {
+        else if (/^(?:(?:virtual:[\/\\])|(?:\w:)|(?:[\/\\]))/gmi.exec(filePath)) {
             return this.files[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
         }
         else {
-            return this.pkgMap[(normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase()];
+            return this.destMap.get((normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase());
         }
     }
     /**
@@ -753,7 +795,8 @@ class Program {
         //look through all files in scope for matches
         for (const scope of this.getScopesForFile(originFile)) {
             for (const file of scope.getAllFiles()) {
-                if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
+                //skip non-brs files, or files we've already processed
+                if (!(0, reflection_1.isBrsFile)(file) || filesSearched.has(file)) {
                     continue;
                 }
                 filesSearched.add(file);
@@ -786,7 +829,8 @@ class Program {
         }
         //look through all files in scope for matches
         for (const file of scope.getOwnFiles()) {
-            if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
+            //skip non-brs files, or files we've already processed
+            if (!(0, reflection_1.isBrsFile)(file) || filesSearched.has(file)) {
                 continue;
             }
             filesSearched.add(file);
@@ -935,10 +979,12 @@ class Program {
     getReferences(srcPath, position) {
         //find the file
         let file = this.getFile(srcPath);
-        if (!file) {
+        if ((0, reflection_1.isBrsFile)(file) || (0, reflection_1.isXmlFile)(file)) {
+            return file.getReferences(position);
+        }
+        else {
             return null;
         }
-        return file.getReferences(position);
     }
     /**
      * Transpile a single file and get the result as a string.
@@ -949,168 +995,211 @@ class Program {
      * @param filePath can be a srcPath or a destPath
      */
     async getTranspiledFileContents(filePath) {
-        let fileMap = await roku_deploy_1.rokuDeploy.getFilePaths(this.options.files, this.options.rootDir);
-        //remove files currently loaded in the program, we will transpile those instead (even if just for source maps)
-        let filteredFileMap = [];
-        for (let fileEntry of fileMap) {
-            if (this.hasFile(fileEntry.src) === false) {
-                filteredFileMap.push(fileEntry);
+        const file = this.getFile(filePath);
+        return this.getTranspiledFileContentsPipeline.run(async () => {
+            const result = {
+                destPath: file.destPath,
+                pkgPath: file.pkgPath,
+                srcPath: file.srcPath
+            };
+            const expectedPkgPath = file.pkgPath.toLowerCase();
+            const expectedMapPath = `${expectedPkgPath}.map`;
+            const expectedTypedefPkgPath = expectedPkgPath.replace(/\.brs$/i, '.d.bs');
+            //add a temporary plugin to tap into the file writing process
+            const plugin = this.plugins.addFirst({
+                name: 'getTranspiledFileContents',
+                beforeWriteFile: (event) => {
+                    const pkgPath = event.file.pkgPath.toLowerCase();
+                    switch (pkgPath) {
+                        //this is the actual transpiled file
+                        case expectedPkgPath:
+                            result.code = event.file.data.toString();
+                            break;
+                        //this is the sourcemap
+                        case expectedMapPath:
+                            result.map = event.file.data.toString();
+                            break;
+                        //this is the typedef
+                        case expectedTypedefPkgPath:
+                            result.typedef = event.file.data.toString();
+                            break;
+                        default:
+                        //no idea what this file is. just ignore it
+                    }
+                    //mark every file as processed so it they don't get written to the output directory
+                    event.processedFiles.add(event.file);
+                }
+            });
+            try {
+                //now that the plugin has been registered, run the build with just this file
+                await this.build({
+                    files: [file]
+                });
+            }
+            finally {
+                this.plugins.remove(plugin);
             }
+            return result;
+        });
+    }
+    /**
+     * Get the absolute output path for a file
+     */
+    getOutputPath(file, stagingDir = this.getStagingDir()) {
+        return (0, util_1.standardizePath) `${stagingDir}/${file.pkgPath}`;
+    }
+    getStagingDir(stagingDir) {
+        var _a, _b;
+        let result = (_a = stagingDir !== null && stagingDir !== void 0 ? stagingDir : this.options.stagingDir) !== null && _a !== void 0 ? _a : this.options.stagingDir;
+        if (!result) {
+            result = roku_deploy_1.rokuDeploy.getOptions(this.options).stagingDir;
         }
-        const { entries, astEditor } = this.beforeProgramTranspile(fileMap, this.options.stagingDir);
-        const result = this._getTranspiledFileContents(this.getFile(filePath));
-        this.afterProgramTranspile(entries, astEditor);
+        result = (0, util_1.standardizePath) `${path.resolve((_b = this.options.cwd) !== null && _b !== void 0 ? _b : process.cwd(), result !== null && result !== void 0 ? result : '/')}`;
         return result;
     }
     /**
-     * Internal function used to transpile files.
-     * This does not write anything to the file system
+     * Prepare the program for building
+     * @param files the list of files that should be prepared
      */
-    _getTranspiledFileContents(file, outputPath) {
-        const editor = new AstEditor_1.AstEditor();
-        this.plugins.emit('beforeFileTranspile', {
+    async prepare(files) {
+        const programEvent = {
             program: this,
-            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 = {
-            program: this,
-            file: file,
-            outputPath: outputPath,
-            editor: editor,
-            code: result.code,
-            map: result.map,
-            typedef: typedef
+            editor: this.editor,
+            files: files
         };
-        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
-        };
-    }
-    beforeProgramTranspile(fileEntries, stagingDir) {
-        // map fileEntries using their path as key, to avoid excessive "find()" operations
-        const mappedFileEntries = fileEntries.reduce((collection, entry) => {
-            collection[(0, util_1.standardizePath) `${entry.src}`] = entry;
-            return collection;
-        }, {});
-        const getOutputPath = (file) => {
-            let filePathObj = mappedFileEntries[(0, util_1.standardizePath) `${file.srcPath}`];
-            if (!filePathObj) {
-                //this file has been added in-memory, from a plugin, for example
-                filePathObj = {
-                    //add an interpolated src path (since it doesn't actually exist in memory)
-                    src: `bsc:/${file.pkgPath}`,
-                    dest: file.pkgPath
-                };
+        //assign an editor to every file
+        for (const file of files) {
+            //if the file doesn't have an editor yet, assign one now
+            if (!file.editor) {
+                file.editor = new Editor_1.Editor();
             }
-            //replace the file extension
-            let outputPath = filePathObj.dest.replace(/\.bs$/gi, '.brs');
-            //prepend the staging folder path
-            outputPath = (0, util_1.standardizePath) `${stagingDir}/${outputPath}`;
-            return outputPath;
-        };
-        const entries = Object.values(this.files).map(file => {
-            return {
+        }
+        files.sort((a, b) => {
+            if (a.pkgPath < b.pkgPath) {
+                return -1;
+            }
+            else if (a.pkgPath > b.pkgPath) {
+                return 1;
+            }
+            else {
+                return 1;
+            }
+        });
+        await this.plugins.emitAsync('beforePrepareProgram', programEvent);
+        await this.plugins.emitAsync('prepareProgram', programEvent);
+        const stagingDir = this.getStagingDir();
+        const entries = [];
+        for (const file of files) {
+            //if the file doesn't have an editor yet, assign one now
+            if (!file.editor) {
+                file.editor = new Editor_1.Editor();
+            }
+            const event = {
+                program: this,
                 file: file,
-                outputPath: getOutputPath(file)
+                editor: file.editor,
+                outputPath: this.getOutputPath(file, stagingDir)
             };
-            //sort the entries to make transpiling more deterministic
-        }).sort((a, b) => {
-            return a.file.srcPath < b.file.srcPath ? -1 : 1;
+            await this.plugins.emitAsync('beforePrepareFile', event);
+            await this.plugins.emitAsync('prepareFile', event);
+            await this.plugins.emitAsync('afterPrepareFile', event);
+            //TODO remove this in v1
+            entries.push(event);
+        }
+        await this.plugins.emitAsync('afterPrepareProgram', programEvent);
+        return files;
+    }
+    /**
+     * Generate the contents of every file
+     */
+    async serialize(files) {
+        const allFiles = new Map();
+        const serializeProgramEvent = await this.plugins.emitAsync('beforeSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
         });
-        const astEditor = new AstEditor_1.AstEditor();
-        this.plugins.emit('beforeProgramTranspile', {
+        await this.plugins.emitAsync('onSerializeProgram', {
             program: this,
-            entries: entries,
-            editor: astEditor
+            files: files,
+            result: allFiles
         });
-        return {
-            entries: entries,
-            getOutputPath: getOutputPath,
-            astEditor: astEditor
-        };
-    }
-    async transpile(fileEntries, stagingDir) {
-        const { entries, getOutputPath, astEditor } = this.beforeProgramTranspile(fileEntries, stagingDir);
-        const processedFiles = new Set();
-        const transpileFile = async (srcPath, outputPath) => {
-            //find the file in the program
-            const file = this.getFile(srcPath);
-            //mark this file as processed so we don't process it more than once
-            processedFiles.add(outputPath === null || outputPath === void 0 ? void 0 : outputPath.toLowerCase());
-            //skip transpiling typedef files
-            if ((0, reflection_1.isBrsFile)(file) && file.isTypedef) {
-                return;
-            }
-            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 = fileTranspileResult.map ? fsExtra.writeFile(`${outputPath}.map`, fileTranspileResult.map.toString()) : null;
-            await Promise.all([
-                fsExtra.writeFile(outputPath, fileTranspileResult.code),
-                writeMapPromise
-            ]);
-            if (fileTranspileResult.typedef) {
-                const typedefPath = outputPath.replace(/\.brs$/i, '.d.bs');
-                await fsExtra.writeFile(typedefPath, fileTranspileResult.typedef);
-            }
-        };
-        let promises = entries.map(async (entry) => {
-            var _a;
-            return transpileFile((_a = entry === null || entry === void 0 ? void 0 : entry.file) === null || _a === void 0 ? void 0 : _a.srcPath, entry.outputPath);
+        //sort the entries to make transpiling more deterministic
+        files = serializeProgramEvent.files.sort((a, b) => {
+            return a.srcPath < b.srcPath ? -1 : 1;
         });
-        //if there's no bslib file already loaded into the program, copy it to the staging directory
-        if (!this.getFile(bslibAliasedRokuModulesPkgPath) && !this.getFile((0, util_1.standardizePath) `source/bslib.brs`)) {
-            promises.push(util_1.util.copyBslibToStaging(stagingDir));
+        // serialize each file
+        for (const file of files) {
+            const event = {
+                program: this,
+                file: file,
+                result: allFiles
+            };
+            await this.plugins.emitAsync('beforeSerializeFile', event);
+            await this.plugins.emitAsync('serializeFile', event);
+            await this.plugins.emitAsync('afterSerializeFile', event);
         }
-        await Promise.all(promises);
-        //transpile any new files that plugins added since the start of this transpile process
-        do {
-            promises = [];
-            for (const key in this.files) {
-                const file = this.files[key];
-                //this is a new file
-                const outputPath = getOutputPath(file);
-                if (!processedFiles.has(outputPath === null || outputPath === void 0 ? void 0 : outputPath.toLowerCase())) {
-                    promises.push(transpileFile(file === null || file === void 0 ? void 0 : file.srcPath, outputPath));
-                }
-            }
-            if (promises.length > 0) {
-                this.logger.info(`Transpiling ${promises.length} new files`);
-                await Promise.all(promises);
-            }
-        } while (promises.length > 0);
-        this.afterProgramTranspile(entries, astEditor);
+        this.plugins.emit('afterSerializeProgram', {
+            program: this,
+            files: files,
+            result: allFiles
+        });
+        return allFiles;
     }
-    afterProgramTranspile(entries, astEditor) {
-        this.plugins.emit('afterProgramTranspile', {
+    /**
+     * Write the entire project to disk
+     */
+    async write(stagingDir, files) {
+        const programEvent = await this.plugins.emitAsync('beforeWriteProgram', {
             program: this,
-            entries: entries,
-            editor: astEditor
+            files: files,
+            stagingDir: stagingDir
+        });
+        //empty the staging directory
+        await fsExtra.emptyDir(stagingDir);
+        const serializedFiles = [...files]
+            .map(([, serializedFiles]) => serializedFiles)
+            .flat();
+        //write all the files to disk (asynchronously)
+        await Promise.all(serializedFiles.map(async (file) => {
+            const event = await this.plugins.emitAsync('beforeWriteFile', {
+                program: this,
+                file: file,
+                outputPath: this.getOutputPath(file, stagingDir),
+                processedFiles: new Set()
+            });
+            await this.plugins.emitAsync('writeFile', event);
+            await this.plugins.emitAsync('afterWriteFile', event);
+        }));
+        await this.plugins.emitAsync('afterWriteProgram', programEvent);
+    }
+    /**
+     * Build the project. This transpiles/transforms/copies all files and moves them to the staging directory
+     * @param options the list of options used to build the program
+     */
+    async build(options) {
+        //run a single build at a time
+        await this.buildPipeline.run(async () => {
+            var _a;
+            const stagingDir = this.getStagingDir(options === null || options === void 0 ? void 0 : options.stagingDir);
+            const event = await this.plugins.emitAsync('beforeBuildProgram', {
+                program: this,
+                editor: this.editor,
+                files: (_a = options === null || options === void 0 ? void 0 : options.files) !== null && _a !== void 0 ? _a : Object.values(this.files)
+            });
+            //prepare the program (and files) for building
+            event.files = await this.prepare(event.files);
+            //stage the entire program
+            const serializedFilesByFile = await this.serialize(event.files);
+            await this.write(stagingDir, serializedFilesByFile);
+            await this.plugins.emitAsync('afterBuildProgram', event);
+            //undo all edits for the program
+            this.editor.undoAll();
+            //undo all edits for each file
+            for (const file of event.files) {
+                file.editor.undoAll();
+            }
         });
-        astEditor.undoAll();
     }
     /**
      * Find a list of files in the program that have a function with the given name (case INsensitive)
@@ -1185,6 +1274,7 @@ class Program {
      * Get a map of the manifest information
      */
     getManifest() {
+        var _a, _b;
         if (!this._manifest) {
             //load the manifest file.
             //TODO update this to get the manifest from the files array or require it in the options...we shouldn't assume the location of the manifest
@@ -1193,7 +1283,27 @@ 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 = (0, Manifest_1.parseManifest)(contents);
+                let parsedManifest = (0, Manifest_1.parseManifest)(contents);
+                // Lift the bs_consts defined in the manifest
+                let bsConsts = (0, Manifest_1.getBsConst)(parsedManifest, false);
+                // Override or delete any bs_consts defined in the bs config
+                for (const key in (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.manifest) === null || _b === void 0 ? void 0 : _b.bs_const) {
+                    const value = this.options.manifest.bs_const[key];
+                    if (value === null) {
+                        bsConsts.delete(key);
+                    }
+                    else {
+                        bsConsts.set(key, value);
+                    }
+                }
+                // convert the new list of bs consts back into a string for the rest of the down stream systems to use
+                let constString = '';
+                for (const [key, value] of bsConsts) {
+                    constString += `${constString !== '' ? ';' : ''}${key}=${value.toString()}`;
+                }
+                // Set the updated bs_const value
+                parsedManifest.set('bs_const', constString);
+                this._manifest = parsedManifest;
             }
             catch (err) {
                 this._manifest = new Map();
@@ -1202,16 +1312,29 @@ class Program {
         return this._manifest;
     }
     dispose() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         this.plugins.emit('beforeProgramDispose', { program: this });
         for (let filePath in this.files) {
-            this.files[filePath].dispose();
+            (_b = (_a = this.files[filePath]) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
         }
         for (let name in this.scopes) {
-            this.scopes[name].dispose();
+            (_d = (_c = this.scopes[name]) === null || _c === void 0 ? void 0 : _c.dispose) === null || _d === void 0 ? void 0 : _d.call(_c);
         }
-        this.globalScope.dispose();
-        this.dependencyGraph.dispose();
+        (_f = (_e = this.globalScope) === null || _e === void 0 ? void 0 : _e.dispose) === null || _f === void 0 ? void 0 : _f.call(_e);
+        (_h = (_g = this.dependencyGraph) === null || _g === void 0 ? void 0 : _g.dispose) === null || _h === void 0 ? void 0 : _h.call(_g);
     }
 }
 exports.Program = Program;
+class ProvideFileEventInternal {
+    constructor(program, srcPath, destPath, data, fileFactory) {
+        var _a;
+        this.program = program;
+        this.srcPath = srcPath;
+        this.destPath = destPath;
+        this.data = data;
+        this.fileFactory = fileFactory;
+        this.files = [];
+        this.srcExtension = (_a = path.extname(srcPath)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    }
+}
 //# sourceMappingURL=Program.js.map