brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/lsp/ProjectManager.d.ts

@@ -0,0 +1,288 @@
+import type { FileRenameTextEdit, LspDiagnostic, LspProject } from './LspProject';
+import type { Hover, Position, Range, Location, SignatureHelp, DocumentSymbol, WorkspaceSymbol, CompletionList, CancellationToken, SelectionRange } from 'vscode-languageserver-protocol';
+import type { FileChange, MaybePromise } from '../interfaces';
+import { BusyStatusTracker } from '../BusyStatusTracker';
+import { PathFilterer } from './PathFilterer';
+import type { Logger, LogLevel } from '../logging';
+import type { BrightScriptProjectConfiguration } from '../LanguageServer';
+/**
+ * Manages all brighterscript projects for the language server
+ */
+export declare class ProjectManager {
+    constructor(options?: {
+        pathFilterer: PathFilterer;
+        logger?: Logger;
+    });
+    private pathFilterer;
+    private logger;
+    /**
+     * Collection of all projects
+     */
+    projects: LspProject[];
+    /**
+     * Collection of standalone projects. These are projects that are not part of a workspace, but are instead single files.
+     * All of these are also present in the `projects` collection.
+     */
+    private standaloneProjects;
+    private documentManager;
+    static documentManagerDelay: number;
+    /**
+     * Maximum number of projects to activate or validate concurrently during syncProjects.
+     * Limits CPU spikes when many projects are discovered (e.g. in large monorepos).
+     */
+    projectActivationConcurrencyLimit: number;
+    busyStatusTracker: BusyStatusTracker<LspProject>;
+    /**
+     * Cache for PathCollection instances per project. Avoids recreating PathCollection
+     * on every document flush, which is wasteful since file patterns only change when a project is reloaded.
+     */
+    private projectFiltererCache;
+    /**
+     * Get or create a cached PathCollection for the given project.
+     * The filterer is invalidated when the project is removed and garbage collected.
+     */
+    private getProjectFilterer;
+    /**
+     * Apply all of the queued document changes. This should only be called as a result of the documentManager flushing changes, and never called manually
+     * @param event the document changes that have occurred since the last time we applied
+     */
+    private flushDocumentChanges;
+    /**
+     * Get a standalone project for a given file path
+     */
+    private getStandaloneProject;
+    /**
+     * Create a project that validates a single file. This is useful for getting language support for files that don't belong to a project
+     */
+    private createStandaloneProject;
+    private removeStandaloneProject;
+    /**
+     * A promise that's set when a sync starts, and resolved when the sync is complete
+     */
+    private syncPromise;
+    private firstSync;
+    /**
+     * Monotonically increasing counter used to detect stale sync cycles.
+     * When a new `syncProjects` call arrives, any in-progress activation or validation
+     * from a previous cycle will see a mismatched generation and bail out.
+     */
+    private syncGeneration;
+    /**
+     * Get a promise that resolves when this manager is finished initializing
+     */
+    onInitialized(): Promise<[PromiseSettledResult<void>, PromiseSettledResult<void>, ...PromiseSettledResult<void>[]]>;
+    /**
+     * Get a promise that resolves when the project manager is idle (no pending work)
+     */
+    onIdle(): Promise<void>;
+    /**
+     * Given a list of all desired projects, create any missing projects and destroy and projects that are no longer available
+     * Treat workspaces that don't have a bsconfig.json as a project.
+     * Handle situations where bsconfig.json files were added or removed (to elevate/lower workspaceFolder projects accordingly)
+     * Leave existing projects alone if they are not affected by these changes
+     * @param workspaceConfigs an array of workspaces
+     */
+    syncProjects(workspaceConfigs: WorkspaceConfig[], forceReload?: boolean): Promise<void>;
+    /**
+     * Run async actions over a list of items with a concurrency limit.
+     * Uses a worker-pool pattern: `concurrencyLimit` workers pull items from a shared queue.
+     */
+    private runWithConcurrencyLimit;
+    private fileChangesQueue;
+    handleFileChanges(changes: FileChange[]): Promise<void>;
+    /**
+     * Handle when files or directories are added, changed, or deleted in the workspace.
+     * This is safe to call any time. Changes will be queued and flushed at the correct times
+     */
+    private _handleFileChanges;
+    /**
+     * Handle a single file change. If the file is a directory, this will recursively read all files in the directory and call `handleFileChanges` again
+     */
+    private handleFileChange;
+    /**
+     * Handle when a file is closed in the editor (this mostly just handles removing standalone projects)
+     */
+    handleFileClose(event: {
+        srcPath: string;
+    }): Promise<void>;
+    /**
+     * Given a project, forcibly reload it by removing it and re-adding it
+     */
+    private reloadProject;
+    /**
+     * Get all the semantic tokens for the given file
+     * @returns an array of semantic tokens
+     */
+    getSemanticTokens(options: {
+        srcPath: string;
+    }): Promise<import("../interfaces").SemanticToken[]>;
+    /**
+     * Get a string containing the transpiled contents of the file at the given path
+     * @returns the transpiled contents of the file as a string
+     */
+    transpileFile(options: {
+        srcPath: string;
+    }): Promise<import("..").FileTranspileResult>;
+    /**
+     *  Get the completions for the given position in the file
+     */
+    getCompletions(options: {
+        srcPath: string;
+        position: Position;
+        cancellationToken?: CancellationToken;
+    }): Promise<CompletionList>;
+    /**
+     * Get the hover information for the given position in the file. If multiple projects have hover information, the projects will be raced and
+     * the fastest result will be returned
+     * @returns the hover information or undefined if no hover information was found
+     */
+    getHover(options: {
+        srcPath: string;
+        position: Position;
+    }): Promise<Hover>;
+    /**
+     * Get the definition for the symbol at the given position in the file
+     * @returns a list of locations where the symbol under the position is defined in the project
+     */
+    getDefinition(options: {
+        srcPath: string;
+        position: Position;
+    }): Promise<Location[]>;
+    getSignatureHelp(options: {
+        srcPath: string;
+        position: Position;
+    }): Promise<SignatureHelp>;
+    getDocumentSymbol(options: {
+        srcPath: string;
+    }): Promise<DocumentSymbol[]>;
+    getWorkspaceSymbol(): Promise<WorkspaceSymbol[]>;
+    getReferences(options: {
+        srcPath: string;
+        position: Position;
+    }): Promise<Location[]>;
+    /**
+     * Collect file-rename text edits from every project and reconcile them.
+     * If two projects produce different replacement text for the same (uri, range), drop that edit
+     * to avoid mangling source. Otherwise emit the agreed-upon edit once.
+     */
+    getFileRenameEdits(options: {
+        oldSrcPath: string;
+        newSrcPath: string;
+    }): Promise<FileRenameTextEdit[]>;
+    getCodeActions(options: {
+        srcPath: string;
+        range: Range;
+    }): Promise<import("vscode-languageserver-types").CodeAction[]>;
+    getFixAllCodeActions(options: {
+        srcPath: string;
+    }): Promise<import("vscode-languageserver-types").CodeAction[]>;
+    getSelectionRanges(options: {
+        srcPath: string;
+        positions: Position[];
+    }): Promise<SelectionRange[]>;
+    /**
+     * Scan a given workspace for all `bsconfig.json` files. If at least one is found, then only folders who have bsconfig.json are returned.
+     * If none are found, then the workspaceFolder itself is treated as a project
+     */
+    private discoverProjectsForWorkspace;
+    /**
+     * Returns true if we have this project, or false if we don't
+     * @returns true if the project exists, or false if it doesn't
+     */
+    private hasProject;
+    /**
+     * Get a project with the specified path
+     * @param param path to the project or an obj that has `projectPath` prop
+     * @returns a project, or undefined if no project was found
+     */
+    private getProject;
+    /**
+     * Remove a project from the language server
+     */
+    private removeProject;
+    /**
+     * A unique project counter to help distinguish log entries in lsp mode
+     */
+    private static projectNumberSequence;
+    private static projectNumberCache;
+    /**
+     * Get a projectNumber for a given config. Try to reuse project numbers when we've seen this project before
+     *  - If the config already has one, use that.
+     *  - If we've already seen this config before, use the same project number as before
+     */
+    private getProjectNumber;
+    /**
+     * Constructs a project for the given config. Just makes the project, doesn't activate it
+     * @returns a new project, or the existing project if one already exists with this config info
+     */
+    private constructProject;
+    /**
+     * Constructs a project for the given config
+     * @returns a new project, or the existing project if one already exists with this config info
+     */
+    private createAndActivateProject;
+    private activateProject;
+    on(eventName: 'validate-begin', handler: (data: {
+        project: LspProject;
+    }) => MaybePromise<void>): any;
+    on(eventName: 'validate-end', handler: (data: {
+        project: LspProject;
+    }) => MaybePromise<void>): any;
+    on(eventName: 'critical-failure', handler: (data: {
+        project: LspProject;
+        message: string;
+    }) => MaybePromise<void>): any;
+    on(eventName: 'project-activate', handler: (data: {
+        project: LspProject;
+    }) => MaybePromise<void>): any;
+    on(eventName: 'diagnostics', handler: (data: {
+        project: LspProject;
+        diagnostics: LspDiagnostic[];
+    }) => MaybePromise<void>): any;
+    private emit;
+    private emitter;
+    dispose(): void;
+}
+export interface WorkspaceConfig {
+    /**
+     * Absolute path to the folder where the workspace resides
+     */
+    workspaceFolder: string;
+    /**
+     * A list of glob patterns used to _exclude_ files from various bsconfig searches
+     */
+    excludePatterns?: string[];
+    /**
+     * A list of project paths that should be used to create projects in place of discovery.
+     */
+    projects?: BrightScriptProjectConfiguration[];
+    /**
+     * Language server configuration options
+     */
+    languageServer: {
+        /**
+         * Should the projects in this workspace be run in their own dedicated worker threads, or all run on the main thread
+         */
+        enableThreading: boolean;
+        /**
+         * Should the language server automatically discover projects in this workspace?
+         */
+        enableProjectDiscovery: boolean;
+        /**
+         * A list of glob patterns used to _exclude_ files from project discovery
+         */
+        projectDiscoveryExclude?: Record<string, boolean>;
+        /**
+         * The log level to use for this workspace
+         */
+        logLevel?: LogLevel | string;
+        /**
+         * Maximum depth to search for Roku projects
+         */
+        projectDiscoveryMaxDepth?: number;
+        /**
+         * The maximum number of projects that can be activated concurrently
+         */
+        projectActivationConcurrencyLimit?: number;
+    };
+}