brighterscript 1.0.0-alpha.1 → 1.0.0-alpha.13

package/dist/Program.d.ts

@@ -1,14 +1,24 @@
-import type { CodeAction, CompletionItem, Position, Range, SignatureInformation } from 'vscode-languageserver';
+import type { CodeAction, CompletionItem, Position, Range, SignatureInformation, SymbolInformation } from 'vscode-languageserver';
 import { Location } from 'vscode-languageserver';
 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 } from './interfaces';
+import type { BsDiagnostic, FileReference, FileObj, BscFile, SemanticToken } 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';
+export interface SourceObj {
+    srcPath: string;
+    source: string;
+    definitions?: string;
+}
+export interface TranspileObj {
+    file: BscFile;
+    outputPath: string;
+}
 export interface SignatureInfoObj {
     index: number;
     key: string;
@@ -55,13 +65,20 @@ export declare class Program {
     /**
      * The path to bslib.brs (the BrightScript runtime for certain BrighterScript features)
      */
-    get bslibPkgPath(): string;
+    get bslibPkgPath(): "pkg:/source/roku_modules/bslib/bslib.brs" | "pkg:/source/roku_modules/rokucommunity_bslib/bslib.brs" | "pkg:/source/bslib.brs";
     get bslibPrefix(): "rokucommunity_bslib" | "bslib";
     /**
-     * A map of every file loaded into this program, indexed by its original file location
+     * A map of every file loaded ino this program, indexed by its lower-case pkgPath
      */
-    files: Record<string, BrsFile | XmlFile>;
     private pkgMap;
+    /**
+     * A map of every file loaded into this program, indexed by its lower-case srcPath
+     */
+    private files;
+    /**
+     * Get a copy of the list of files currently loaded in the program
+     */
+    getFiles(): BscFile[];
     private scopes;
     protected addScope(scope: Scope): void;
     /**
@@ -96,7 +113,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(): File[];
+    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.
@@ -106,9 +123,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;
-    getPkgPath(...args: any[]): any;
+    hasFile(filePath: string, normalizePath?: boolean): boolean;
     /**
      * roku filesystem is case INsensitive, so find the scope by key case insensitive
      * @param scopeName
@@ -122,51 +139,50 @@ 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 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>(relativePath: 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.
      */
     createSourceScope(): void;
-    /**
-     * Find the file by its absolute path. This is case INSENSITIVE, since
-     * 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
-     */
-    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.
-     */
-    getFilesByPkgPaths<T extends BscFile[]>(pkgPaths: string[]): T;
-    /**
-     * Get a file with the specified (platform-normalized) pkg path.
-     * If not found, return undefined
-     */
-    getFileByPkgPath<T extends BscFile>(pkgPath: string): T;
     /**
      * Remove a set of files from the program
-     * @param absolutePaths
+     * @param srcPaths
      */
-    removeFiles(absolutePaths: string[]): void;
+    removeFiles(srcPaths: string[]): 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(filePath: string, normalizePath?: boolean): void;
+    /**
+     * Remove all files from the program that are in the specified folder path (recursive)
+     * @param folderSrcPath The absolute path to the folder on disk
+     * @param normalizePath should the provided path be normalized before use?
      */
-    removeFile(pathAbsolute: string): void;
+    removeFilesInFolder(folderSrcPath: 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
@@ -182,9 +198,10 @@ export declare class Program {
     private fileIsIncludedInAnyScope;
     /**
      * Get the file at the given path
-     * @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
      */
-    private getFile;
+    getFile<T extends BscFile>(filePath: string, normalizePath?: boolean): T;
     /**
      * Get a list of all scopes the file is loaded into
      * @param file
@@ -194,29 +211,41 @@ export declare class Program {
     getStatementsForXmlFile(scope: XmlScope, filterName?: string): FileLink<FunctionStatement>[];
     /**
      * Find all available completion items at the given position
-     * @param pathAbsolute
+     * @param srcPath The absolute path to the source file on disk
      * @param lineIndex
      * @param columnIndex
      */
-    getCompletions(pathAbsolute: string, position: Position): CompletionItem[];
+    getCompletions(srcPath: string, position: Position): CompletionItem[];
     /**
      * Goes through each file and builds a list of workspace symbols for the program. Used by LanguageServer's onWorkspaceSymbol functionality
      */
-    getWorkspaceSymbols(): import("vscode-languageserver-types").SymbolInformation[];
+    getWorkspaceSymbols(): SymbolInformation[];
     /**
      * Given a position in a file, if the position is sitting on some type of identifier,
      * go to the definition of that identifier (where this thing was first defined)
+     * @param srcPath The absolute path to the source file on disk
      */
-    getDefinition(pathAbsolute: string, position: Position): Location[];
-    getHover(pathAbsolute: string, position: Position): Promise<import("vscode-languageserver-types").Hover>;
+    getDefinition(srcPath: string, position: Position): Location[];
+    /**
+     * @param srcPath The absolute path to the source file on disk
+     */
+    getHover(srcPath: string, position: Position): Promise<import("vscode-languageserver-types").Hover>;
     /**
      * Compute code actions for the given file and range
+     * @param srcPath The absolute path to the source file on disk
+     */
+    getCodeActions(srcPath: string, range: Range): CodeAction[];
+    /**
+     * Get semantic tokens for the specified file
      */
-    getCodeActions(pathAbsolute: string, range: Range): CodeAction[];
+    getSemanticTokens(srcPath: string): SemanticToken[];
     getSignatureHelp(filepath: string, position: Position): SignatureInfoObj[];
     private getPartialStatementInfo;
     private getPartialItemCounts;
-    getReferences(pathAbsolute: string, position: Position): Location[] | Promise<Location[]>;
+    /**
+     * @param srcPath The absolute path to the source file on disk
+     */
+    getReferences(srcPath: string, position: Position): Location[] | Promise<Location[]>;
     /**
      * Get a list of all script imports, relative to the specified pkgPath
      * @param sourcePkgPath - the pkgPath of the source that wants to resolve script imports.
@@ -225,9 +254,10 @@ 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
      */
-    getTranspiledFileContents(pathAbsolute: string): {
-        pathAbsolute: string;
+    getTranspiledFileContents(srcPath: string): {
+        srcPath: string;
         pkgPath: string;
         code: string;
         map: import("source-map").SourceMapGenerator;
@@ -236,15 +266,15 @@ export declare class Program {
     /**
      * 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)
      */
-    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;
 }