@spyglassmc/core 0.1.0

package/lib/service/MetaRegistry.js

@@ -0,0 +1,192 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MetaRegistry_languages, _MetaRegistry_checkers, _MetaRegistry_colorizers, _MetaRegistry_completers, _MetaRegistry_dependencyProviders, _MetaRegistry_formatters, _MetaRegistry_inlayHintProviders, _MetaRegistry_linters, _MetaRegistry_parsers, _MetaRegistry_signatureHelpProviders, _MetaRegistry_symbolRegistrars, _MetaRegistry_uriBinders;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaRegistry = void 0;
+const common_1 = require("../common");
+const processor_1 = require("../processor");
+/* istanbul ignore next */
+/**
+ * The meta registry of Spyglass. You can register new parsers, processors, and languages here.
+ */
+class MetaRegistry {
+    constructor() {
+        /**
+         * A map from language IDs to language options.
+         */
+        _MetaRegistry_languages.set(this, new Map());
+        _MetaRegistry_checkers.set(this, new Map());
+        _MetaRegistry_colorizers.set(this, new Map());
+        _MetaRegistry_completers.set(this, new Map());
+        _MetaRegistry_dependencyProviders.set(this, new Map());
+        _MetaRegistry_formatters.set(this, new Map());
+        _MetaRegistry_inlayHintProviders.set(this, new Set());
+        _MetaRegistry_linters.set(this, new Map());
+        _MetaRegistry_parsers.set(this, new Map());
+        _MetaRegistry_signatureHelpProviders.set(this, new Set());
+        _MetaRegistry_symbolRegistrars.set(this, new Map());
+        _MetaRegistry_uriBinders.set(this, new Set());
+        processor_1.checker.registerCheckers(this);
+        processor_1.colorizer.registerColorizers(this);
+        processor_1.completer.registerCompleters(this);
+        processor_1.formatter.registerFormatters(this);
+        processor_1.linter.registerLinters(this);
+    }
+    /**
+     * Registers a new language.
+     * @param languageID The language ID. e.g. `"mcfunction"`
+     * @param options The language options for this language.
+     */
+    registerLanguage(languageID, options) {
+        __classPrivateFieldGet(this, _MetaRegistry_languages, "f").set(languageID, options);
+    }
+    /**
+     * An array of all registered language IDs.
+     */
+    getLanguages() {
+        return Array.from(__classPrivateFieldGet(this, _MetaRegistry_languages, "f").keys());
+    }
+    isSupportedLanguage(language) {
+        return __classPrivateFieldGet(this, _MetaRegistry_languages, "f").has(language);
+    }
+    /**
+     * An array of file extensions (including the leading dot (`.`)) that are supported.
+     */
+    getSupportedFileExtensions() {
+        return [...__classPrivateFieldGet(this, _MetaRegistry_languages, "f").values()].flatMap(v => v.extensions);
+    }
+    /**
+     * An array of characters that trigger a completion request.
+     */
+    getTriggerCharacters() {
+        return Array.from(__classPrivateFieldGet(this, _MetaRegistry_languages, "f").values()).flatMap(v => v.triggerCharacters ?? []);
+    }
+    /**
+     * @param fileExtension The file extension including the leading dot. e.g. `".mcfunction"`.
+     * @returns The language ID registered for the file extension, or `undefined`.
+     */
+    getLanguageID(fileExtension) {
+        for (const [languageID, { extensions }] of __classPrivateFieldGet(this, _MetaRegistry_languages, "f")) {
+            if (extensions.includes(fileExtension)) {
+                return languageID;
+            }
+        }
+        return undefined;
+    }
+    hasChecker(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_checkers, "f").has(type);
+    }
+    getChecker(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_checkers, "f").get(type) ?? processor_1.checker.fallback;
+    }
+    registerChecker(type, checker) {
+        __classPrivateFieldGet(this, _MetaRegistry_checkers, "f").set(type, checker);
+    }
+    hasColorizer(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_colorizers, "f").has(type);
+    }
+    getColorizer(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_colorizers, "f").get(type) ?? processor_1.colorizer.fallback;
+    }
+    registerColorizer(type, colorizer) {
+        __classPrivateFieldGet(this, _MetaRegistry_colorizers, "f").set(type, colorizer);
+    }
+    hasCompleter(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_completers, "f").has(type);
+    }
+    getCompleter(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_completers, "f").get(type) ?? processor_1.completer.fallback;
+    }
+    registerCompleter(type, completer) {
+        __classPrivateFieldGet(this, _MetaRegistry_completers, "f").set(type, completer);
+    }
+    shouldComplete(languageID, triggerCharacter) {
+        const language = __classPrivateFieldGet(this, _MetaRegistry_languages, "f").get(languageID);
+        return !triggerCharacter || !!language?.triggerCharacters?.includes(triggerCharacter);
+    }
+    getCompleterForLanguageID(languageID) {
+        return __classPrivateFieldGet(this, _MetaRegistry_languages, "f").get(languageID)?.completer ?? processor_1.completer.fallback;
+    }
+    getDependencyProvider(key) {
+        return __classPrivateFieldGet(this, _MetaRegistry_dependencyProviders, "f").get(key);
+    }
+    registerDependencyProvider(key, provider) {
+        __classPrivateFieldGet(this, _MetaRegistry_dependencyProviders, "f").set(key, provider);
+    }
+    hasFormatter(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_formatters, "f").has(type);
+    }
+    getFormatter(type) {
+        return __classPrivateFieldGet(this, _MetaRegistry_formatters, "f").get(type) ?? processor_1.formatter.fallback;
+    }
+    registerFormatter(type, formatter) {
+        __classPrivateFieldGet(this, _MetaRegistry_formatters, "f").set(type, formatter);
+    }
+    registerInlayHintProvider(provider) {
+        __classPrivateFieldGet(this, _MetaRegistry_inlayHintProviders, "f").add(provider);
+    }
+    get inlayHintProviders() {
+        return __classPrivateFieldGet(this, _MetaRegistry_inlayHintProviders, "f");
+    }
+    getLinter(ruleName) {
+        return __classPrivateFieldGet(this, _MetaRegistry_linters, "f").get(ruleName) ?? {
+            configValidator: () => false,
+            linter: processor_1.linter.noop,
+            nodePredicate: () => false,
+        };
+    }
+    registerLinter(ruleName, options) {
+        __classPrivateFieldGet(this, _MetaRegistry_linters, "f").set(ruleName, options);
+    }
+    hasParser(id) {
+        return __classPrivateFieldGet(this, _MetaRegistry_parsers, "f").has(id);
+    }
+    getParser(id) {
+        const ans = __classPrivateFieldGet(this, _MetaRegistry_parsers, "f").get(id);
+        if (!ans) {
+            throw new Error(`There is no parser '${id}'`);
+        }
+        return ans;
+    }
+    getParserLazily(id) {
+        return common_1.Lazy.create(() => this.getParser(id));
+    }
+    registerParser(id, parser) {
+        __classPrivateFieldGet(this, _MetaRegistry_parsers, "f").set(id, parser);
+    }
+    /**
+     * @returns The corresponding `Parser` for the language ID.
+     * @throws If there's no such language in the registry.
+     */
+    getParserForLanguageId(languageID) {
+        if (__classPrivateFieldGet(this, _MetaRegistry_languages, "f").has(languageID)) {
+            return __classPrivateFieldGet(this, _MetaRegistry_languages, "f").get(languageID).parser;
+        }
+        throw new Error(`There is no parser registered for language ID '${languageID}'`);
+    }
+    registerSignatureHelpProvider(provider) {
+        __classPrivateFieldGet(this, _MetaRegistry_signatureHelpProviders, "f").add(provider);
+    }
+    get signatureHelpProviders() {
+        return __classPrivateFieldGet(this, _MetaRegistry_signatureHelpProviders, "f");
+    }
+    registerSymbolRegistrar(id, registrar) {
+        __classPrivateFieldGet(this, _MetaRegistry_symbolRegistrars, "f").set(id, registrar);
+    }
+    get symbolRegistrars() {
+        return __classPrivateFieldGet(this, _MetaRegistry_symbolRegistrars, "f");
+    }
+    registerUriBinder(uriBinder) {
+        __classPrivateFieldGet(this, _MetaRegistry_uriBinders, "f").add(uriBinder);
+    }
+    get uriBinders() {
+        return __classPrivateFieldGet(this, _MetaRegistry_uriBinders, "f");
+    }
+}
+exports.MetaRegistry = MetaRegistry;
+_MetaRegistry_languages = new WeakMap(), _MetaRegistry_checkers = new WeakMap(), _MetaRegistry_colorizers = new WeakMap(), _MetaRegistry_completers = new WeakMap(), _MetaRegistry_dependencyProviders = new WeakMap(), _MetaRegistry_formatters = new WeakMap(), _MetaRegistry_inlayHintProviders = new WeakMap(), _MetaRegistry_linters = new WeakMap(), _MetaRegistry_parsers = new WeakMap(), _MetaRegistry_signatureHelpProviders = new WeakMap(), _MetaRegistry_symbolRegistrars = new WeakMap(), _MetaRegistry_uriBinders = new WeakMap();
+//# sourceMappingURL=MetaRegistry.js.map

package/lib/service/Operations.d.ts

@@ -0,0 +1,8 @@
+export declare class Operations {
+    private readonly undoOps;
+    private readonly redoOps;
+    set<O extends object, K extends keyof O>(obj: O, key: K, value: O[K]): void;
+    undo(): void;
+    redo(): void;
+}
+//# sourceMappingURL=Operations.d.ts.map

package/lib/service/Operations.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operations = void 0;
+class Operations {
+    constructor() {
+        this.undoOps = [];
+        this.redoOps = [];
+    }
+    set(obj, key, value) {
+        const oldValue = obj[key];
+        const op = () => { obj[key] = value; };
+        this.redoOps.push(op);
+        this.undoOps.push(() => { obj[key] = oldValue; });
+        op();
+    }
+    undo() {
+        for (let i = this.undoOps.length - 1; i >= 0; i--) {
+            this.undoOps[i]();
+        }
+    }
+    redo() {
+        this.redoOps.forEach(f => f());
+    }
+}
+exports.Operations = Operations;
+//# sourceMappingURL=Operations.js.map

package/lib/service/Profiler.d.ts

@@ -0,0 +1,33 @@
+import { Logger } from './Logger';
+/**
+ * @example
+ * ```typescript
+ * const __profiler = profilerFactory.get('id')
+ *
+ * // Do Task 1 here
+ * // ...
+ * __profiler.task('Task 1')
+ *
+ * // Do Task 2 here
+ * // ...
+ * __profiler.task('Task 2').finalize()
+ * ```
+ */
+export interface Profiler {
+    /**
+     * Call after a task has been finished.
+     */
+    task(name: string): this;
+    /**
+     * Call after the whole procedure that is being profiled is done.
+     */
+    finalize(): void;
+}
+export declare class ProfilerFactory {
+    #private;
+    private readonly logger;
+    constructor(logger: Logger, enabledProfilers: string[]);
+    get(id: string): Profiler;
+    static noop(): ProfilerFactory;
+}
+//# sourceMappingURL=Profiler.d.ts.map

package/lib/service/Profiler.js

@@ -0,0 +1,76 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ProfilerImpl_finalized, _ProfilerImpl_startTime, _ProfilerImpl_lastTime, _ProfilerImpl_tasks, _ProfilerImpl_longestTaskNameLength, _ProfilerFactory_enabledProfilers;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilerFactory = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const Logger_1 = require("./Logger");
+const TotalTaskName = 'Total';
+class ProfilerImpl {
+    constructor(id, logger) {
+        this.id = id;
+        this.logger = logger;
+        _ProfilerImpl_finalized.set(this, false);
+        _ProfilerImpl_startTime.set(this, void 0);
+        _ProfilerImpl_lastTime.set(this, void 0);
+        _ProfilerImpl_tasks.set(this, []);
+        _ProfilerImpl_longestTaskNameLength.set(this, 0);
+        __classPrivateFieldSet(this, _ProfilerImpl_startTime, __classPrivateFieldSet(this, _ProfilerImpl_lastTime, perf_hooks_1.performance.now(), "f"), "f");
+    }
+    task(name) {
+        if (__classPrivateFieldGet(this, _ProfilerImpl_finalized, "f")) {
+            throw new Error('The profiler is finalized.');
+        }
+        const time = perf_hooks_1.performance.now();
+        __classPrivateFieldGet(this, _ProfilerImpl_tasks, "f").push([name, time - __classPrivateFieldGet(this, _ProfilerImpl_lastTime, "f")]);
+        __classPrivateFieldSet(this, _ProfilerImpl_lastTime, time, "f");
+        __classPrivateFieldSet(this, _ProfilerImpl_longestTaskNameLength, Math.max(__classPrivateFieldGet(this, _ProfilerImpl_longestTaskNameLength, "f"), name.length), "f");
+        this.logger.info(`[Profiler: ${this.id}] Done: ${name}`);
+        return this;
+    }
+    finalize() {
+        __classPrivateFieldSet(this, _ProfilerImpl_finalized, true, "f");
+        __classPrivateFieldGet(this, _ProfilerImpl_tasks, "f").push([TotalTaskName, __classPrivateFieldGet(this, _ProfilerImpl_lastTime, "f") - __classPrivateFieldGet(this, _ProfilerImpl_startTime, "f")]);
+        __classPrivateFieldSet(this, _ProfilerImpl_longestTaskNameLength, Math.max(__classPrivateFieldGet(this, _ProfilerImpl_longestTaskNameLength, "f"), TotalTaskName.length), "f");
+        this.logger.info(`[Profiler: ${this.id}] == Summary ==`);
+        for (const [name, time] of __classPrivateFieldGet(this, _ProfilerImpl_tasks, "f")) {
+            this.logger.info(`[Profiler: ${this.id}] ${name}${' '.repeat(__classPrivateFieldGet(this, _ProfilerImpl_longestTaskNameLength, "f") - name.length)} - ${time} ms`);
+        }
+    }
+}
+_ProfilerImpl_finalized = new WeakMap(), _ProfilerImpl_startTime = new WeakMap(), _ProfilerImpl_lastTime = new WeakMap(), _ProfilerImpl_tasks = new WeakMap(), _ProfilerImpl_longestTaskNameLength = new WeakMap();
+class NoopImpl {
+    task() { return this; }
+    finalize() { }
+}
+class ProfilerFactory {
+    constructor(logger, enabledProfilers) {
+        this.logger = logger;
+        _ProfilerFactory_enabledProfilers.set(this, void 0);
+        __classPrivateFieldSet(this, _ProfilerFactory_enabledProfilers, new Set(enabledProfilers), "f");
+    }
+    get(id) {
+        if (__classPrivateFieldGet(this, _ProfilerFactory_enabledProfilers, "f").has(id)) {
+            return new ProfilerImpl(id, this.logger);
+        }
+        else {
+            return new NoopImpl();
+        }
+    }
+    static noop() {
+        return new ProfilerFactory(Logger_1.Logger.noop(), []);
+    }
+}
+exports.ProfilerFactory = ProfilerFactory;
+_ProfilerFactory_enabledProfilers = new WeakMap();
+//# sourceMappingURL=Profiler.js.map

package/lib/service/Project.d.ts

@@ -0,0 +1,173 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import type { TextDocumentContentChangeEvent } from 'vscode-languageserver-textdocument';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import type { AstNode } from '../node';
+import { FileNode } from '../node';
+import type { LanguageError } from '../source';
+import { SymbolUtil } from '../symbol';
+import { CacheService } from './CacheService';
+import type { Config } from './Config';
+import { Downloader } from './Downloader';
+import { FileService } from './FileService';
+import type { RootUriString } from './fileUtil';
+import { Logger } from './Logger';
+import { MetaRegistry } from './MetaRegistry';
+import { ProfilerFactory } from './Profiler';
+export declare type ProjectInitializerContext = Pick<Project, 'cacheRoot' | 'config' | 'downloader' | 'logger' | 'meta' | 'projectRoot'>;
+export declare type ProjectInitializer = (this: void, ctx: ProjectInitializerContext) => PromiseLike<Record<string, string> | void> | Record<string, string> | void;
+interface Options {
+    cacheRoot: string;
+    downloader?: Downloader;
+    fs?: FileService;
+    initializers?: readonly ProjectInitializer[];
+    logger?: Logger;
+    profilers?: ProfilerFactory;
+    /**
+     * A file path to the root of this project.
+     */
+    projectPath: string;
+    symbols?: SymbolUtil;
+}
+export interface DocAndNode {
+    doc: TextDocument;
+    node: FileNode<AstNode>;
+}
+interface DocumentEvent extends DocAndNode {
+}
+interface DocumentErrorEvent extends DocumentEvent {
+    errors: LanguageError[];
+}
+interface FileEvent {
+    uri: string;
+}
+interface EmptyEvent {
+}
+interface RootsEvent {
+    roots: readonly RootUriString[];
+}
+interface SymbolRegistrarEvent {
+    id: string;
+    checksum: string | undefined;
+}
+export declare type ProjectData = Pick<Project, 'cacheRoot' | 'config' | 'downloader' | 'ensureParsedAndChecked' | 'fs' | 'get' | 'logger' | 'meta' | 'profilers' | 'projectRoot' | 'roots' | 'symbols' | 'ctx'>;
+export declare namespace ProjectData {
+    function mock(data?: Partial<ProjectData>): ProjectData;
+}
+export interface Project extends EventEmitter {
+    on(event: 'documentErrorred', callbackFn: (data: DocumentErrorEvent) => void): this;
+    on(event: 'documentUpdated', callbackFn: (data: DocumentEvent) => void): this;
+    on(event: 'documentRemoved', callbackFn: (data: FileEvent) => void): this;
+    on(event: `file${'Created' | 'Modified' | 'Deleted'}`, callbackFn: (data: FileEvent) => void): this;
+    on(event: 'ready', callbackFn: (data: EmptyEvent) => void): this;
+    on(event: 'rootsUpdated', callbackFn: (data: RootsEvent) => void): this;
+    on(event: 'symbolRegistrarExecuted', callbackFn: (data: SymbolRegistrarEvent) => void): this;
+    once(event: 'documentErrorred', callbackFn: (data: DocumentErrorEvent) => void): this;
+    once(event: 'documentUpdated', callbackFn: (data: DocumentEvent) => void): this;
+    once(event: 'documentRemoved', callbackFn: (data: FileEvent) => void): this;
+    once(event: `file${'Created' | 'Modified' | 'Deleted'}`, callbackFn: (data: FileEvent) => void): this;
+    once(event: 'ready', callbackFn: (data: EmptyEvent) => void): this;
+    once(event: 'rootsUpdated', callbackFn: (data: RootsEvent) => void): this;
+    once(event: 'symbolRegistrarExecuted', callbackFn: (data: SymbolRegistrarEvent) => void): this;
+    emit(event: 'documentErrorred', data: DocumentErrorEvent): boolean;
+    emit(event: 'documentUpdated', data: DocumentEvent): boolean;
+    emit(event: 'documentRemoved', data: FileEvent): boolean;
+    emit(event: `file${'Created' | 'Modified' | 'Deleted'}`, data: FileEvent): boolean;
+    emit(event: 'ready', data: EmptyEvent): boolean;
+    emit(event: 'rootsUpdated', data: RootsEvent): boolean;
+    emit(event: 'symbolRegistrarExecuted', data: SymbolRegistrarEvent): boolean;
+}
+/**
+ * Manage all tracked documents and errors.
+ */
+export declare class Project extends EventEmitter {
+    #private;
+    private static readonly RootSuffix;
+    readonly cacheService: CacheService;
+    config: Config;
+    readonly downloader: Downloader;
+    readonly fs: FileService;
+    readonly logger: Logger;
+    readonly meta: MetaRegistry;
+    readonly profilers: ProfilerFactory;
+    readonly projectPath: string;
+    readonly projectRoot: RootUriString;
+    symbols: SymbolUtil;
+    /**
+     * All tracked root URIs. Each URI in this array is guaranteed to end with a slash (`/`).
+     *
+     * Includes the roots of all dependencies, the project root, and all data pack roots identified
+     * by `pack.mcmeta` files.
+     *
+     * Some URIs in the array may overlap with each other. In such cases, the deeper ones are guaranteed to come
+     * before the shallower ones (e.g. `file:///foo/bar/` will come before `file:///foo/`).
+     */
+    get roots(): readonly RootUriString[];
+    /**
+     * Arbitrary information that will be included in the `project` property of all `Context`s.
+     */
+    get ctx(): Record<string, string>;
+    /**
+     * File path to a directory where all cache files of Spyglass should be stored.
+     */
+    get cacheRoot(): string;
+    private updateRoots;
+    /**
+     * Get all files that are tracked and supported.
+     *
+     * Files in cached archives may not show up in the result as those files
+     * are not loaded into the memory.
+     */
+    getTrackedFiles(): string[];
+    constructor({ cacheRoot, downloader, fs, initializers, logger, profilers, projectPath, }: Options);
+    private setInitPromise;
+    private setReadyPromise;
+    init(): Promise<this>;
+    ready(): Promise<this>;
+    /**
+     * Behavior of the `Project` instance is undefined after this function has settled.
+     */
+    close(): Promise<void>;
+    restart(): Promise<void>;
+    resetCache(): void;
+    /**
+     * @returns The language ID of the file, or the file extension without the leading dot.
+     */
+    private getLanguageID;
+    /**
+     * @returns The cached `TextDocument` and `AstNode` for the URI, or `undefined` when such data isn't available in cache.
+     */
+    get(uri: string): DocAndNode | undefined;
+    /**
+     * @throws FS-related errors
+     */
+    ensureParsed(uri: string): Promise<DocAndNode | undefined>;
+    private parseAndCache;
+    private parse;
+    private cache;
+    private check;
+    ensureChecked(doc: TextDocument, node: FileNode<AstNode>): Promise<void>;
+    private lint;
+    ensureLinted(doc: TextDocument, node: FileNode<AstNode>): void;
+    ensureParsedAndChecked(uri: string): Promise<DocAndNode | undefined>;
+    private bind;
+    /**
+     * Notify that a new document was opened in the editor.
+     */
+    onDidOpen(uri: string, languageID: string, version: number, content: string): void;
+    /**
+     * Notify that an existing document was changed in the editor.
+     * @throws If there is no `TextDocument` corresponding to the URI.
+     */
+    onDidChange(uri: string, changes: TextDocumentContentChangeEvent[], version: number): void;
+    /**
+     * Notify that an existing document was closed in the editor.
+     */
+    onDidClose(uri: string): void;
+    showCacheRoot(): Promise<void>;
+    private tryClearingCache;
+    private shouldRemove;
+    private isOnlyWatched;
+}
+export {};
+//# sourceMappingURL=Project.d.ts.map