brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/Program.d.ts

@@ -4,11 +4,12 @@ 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 } from './interfaces';
+import type { BsDiagnostic, FileReference, FileObj, BscFile, SemanticToken, FileLink } from './interfaces';
 import { XmlScope } from './XmlScope';
 import { Logger } from './Logger';
 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 +24,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 +74,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 +109,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.
@@ -141,24 +138,24 @@ export declare class Program {
     /**
      * Update internal maps with this file reference
      */
-    private setFile;
+    private assignFile;
     /**
      * Remove this file from internal maps
      */
-    private unsetFile;
+    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 srcDestOrPkgPath the absolute path, or 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
      */
-    addOrReplaceFile<T extends BscFile>(srcDestOrPkgPath: string, fileContents: string): T;
+    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
      */
-    addOrReplaceFile<T extends BscFile>(fileEntry: FileObj, fileContents: string): T;
+    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.
@@ -166,14 +163,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(srcPaths: 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 +192,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 +209,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>[];
     /**
@@ -234,6 +241,10 @@ export declare class Program {
      * @param srcPath The absolute path to the source file on disk
      */
     getCodeActions(srcPath: string, range: Range): CodeAction[];
+    /**
+     * Get semantic tokens for the specified file
+     */
+    getSemanticTokens(srcPath: string): SemanticToken[];
     getSignatureHelp(filepath: string, position: Position): SignatureInfoObj[];
     private getPartialStatementInfo;
     private getPartialItemCounts;
@@ -249,27 +260,34 @@ export declare class Program {
     /**
      * Transpile a single file and get the result as a string.
      * This does not write anything to the file system.
-     * @param srcPath The absolute path to the source file on disk
+     * @param srcPath can be a srcPath or a destPath
      */
-    getTranspiledFileContents(srcPath: string): {
-        srcPath: string;
-        pkgPath: string;
-        code: string;
-        map: import("source-map").SourceMapGenerator;
-    };
+    getTranspiledFileContents(srcPath: 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, string>;
     private _manifest;
     dispose(): void;
 }
+export interface FileTranspileResult {
+    srcPath: string;
+    pkgPath: string;
+    code: string;
+    map: SourceMapGenerator;
+    typedef: string;
+}