@spyglassmc/core 0.1.0

package/lib/service/Project.js

@@ -0,0 +1,593 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Project_cacheSaverIntervalId, _Project_clientManagedUris, _Project_configService, _Project_docAndNodes, _Project_initializers, _Project_initPromise, _Project_readyPromise, _Project_watchedFiles, _Project_watcher, _Project_watcherReady, _Project_dependencyRoots, _Project_dependencyFiles, _Project_roots, _Project_ctx, _Project_cacheRoot;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = exports.ProjectData = void 0;
+const chokidar_1 = __importDefault(require("chokidar"));
+const events_1 = __importDefault(require("events"));
+const p_limit_1 = __importDefault(require("p-limit"));
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const _1 = require(".");
+const common_1 = require("../common");
+const node_1 = require("../node");
+const parser_1 = require("../parser");
+const processor_1 = require("../processor");
+const source_1 = require("../source");
+const symbol_1 = require("../symbol");
+const CacheService_1 = require("./CacheService");
+const Config_1 = require("./Config");
+const Context_1 = require("./Context");
+const Dependency_1 = require("./Dependency");
+const Downloader_1 = require("./Downloader");
+const ErrorReporter_1 = require("./ErrorReporter");
+const FileService_1 = require("./FileService");
+const fileUtil_1 = require("./fileUtil");
+const Logger_1 = require("./Logger");
+const MetaRegistry_1 = require("./MetaRegistry");
+const Profiler_1 = require("./Profiler");
+const CacheAutoSaveInterval = 600000; // 10 Minutes.
+var ProjectData;
+(function (ProjectData) {
+    function mock(data = {}) {
+        const cacheRoot = data.cacheRoot ?? '/some/random/garbage/path/that/definitely/does/not/exist';
+        const logger = data.logger ?? Logger_1.Logger.create();
+        const downloader = data.downloader ?? new Downloader_1.Downloader(cacheRoot, logger, _1.LowLevelDownloader.mock({ fixtures: {} }));
+        return {
+            cacheRoot,
+            config: data.config ?? Config_1.VanillaConfig,
+            ctx: data.ctx ?? {},
+            downloader,
+            ensureParsedAndChecked: data.ensureParsedAndChecked,
+            fs: data.fs ?? FileService_1.FileService.create(),
+            get: data.get ?? (() => undefined),
+            logger,
+            meta: data.meta ?? new MetaRegistry_1.MetaRegistry(),
+            profilers: data.profilers ?? Profiler_1.ProfilerFactory.noop(),
+            projectRoot: data.projectRoot ?? 'file:///',
+            roots: data.roots ?? [],
+            symbols: data.symbols ?? new symbol_1.SymbolUtil({}),
+        };
+    }
+    ProjectData.mock = mock;
+})(ProjectData = exports.ProjectData || (exports.ProjectData = {}));
+/* istanbul ignore next */
+/**
+ * Manage all tracked documents and errors.
+ */
+class Project extends events_1.default {
+    constructor({ cacheRoot, downloader, fs = FileService_1.FileService.create(), initializers = [], logger = Logger_1.Logger.create(), profilers = Profiler_1.ProfilerFactory.noop(), projectPath, }) {
+        super();
+        _Project_cacheSaverIntervalId.set(this, void 0);
+        /**
+         * URI of files that are currently managed by the language client.
+         */
+        _Project_clientManagedUris.set(this, new Set());
+        _Project_configService.set(this, void 0);
+        _Project_docAndNodes.set(this, new Map());
+        _Project_initializers.set(this, void 0);
+        _Project_initPromise.set(this, void 0);
+        _Project_readyPromise.set(this, void 0);
+        _Project_watchedFiles.set(this, new Set());
+        _Project_watcher.set(this, void 0);
+        _Project_watcherReady.set(this, false);
+        this.meta = new MetaRegistry_1.MetaRegistry();
+        _Project_dependencyRoots.set(this, void 0);
+        _Project_dependencyFiles.set(this, void 0);
+        _Project_roots.set(this, []
+        /**
+         * 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/`).
+         */
+        );
+        _Project_ctx.set(this, void 0);
+        _Project_cacheRoot.set(this, void 0);
+        __classPrivateFieldSet(this, _Project_cacheRoot, cacheRoot, "f");
+        this.cacheService = new CacheService_1.CacheService(cacheRoot, this);
+        __classPrivateFieldSet(this, _Project_configService, new Config_1.ConfigService(this), "f");
+        this.downloader = downloader ?? new Downloader_1.Downloader(cacheRoot, logger);
+        this.fs = fs;
+        __classPrivateFieldSet(this, _Project_initializers, initializers, "f");
+        this.logger = logger;
+        this.profilers = profilers;
+        this.projectPath = projectPath;
+        this.projectRoot = fileUtil_1.fileUtil.ensureEndingSlash(fileUtil_1.fileUtil.pathToFileUri(projectPath));
+        this.symbols = new symbol_1.SymbolUtil({});
+        __classPrivateFieldSet(this, _Project_ctx, {}, "f");
+        this.logger.info(`[Project] [init] cacheRoot = “${cacheRoot}”`);
+        __classPrivateFieldGet(this, _Project_configService, "f")
+            .on('changed', ({ config }) => {
+            this.config = config;
+            this.logger.info('[Project] [Config] Changed');
+        })
+            .on('error', ({ error, uri }) => this.logger.error(`[Project] [Config] Failed loading “${uri}”`, error));
+        this.setInitPromise();
+        this.setReadyPromise();
+        __classPrivateFieldSet(this, _Project_cacheSaverIntervalId, setInterval(() => this.cacheService.save(), CacheAutoSaveInterval), "f");
+        this
+            .on('documentUpdated', ({ doc, node }) => {
+            this.emit('documentErrorred', {
+                doc,
+                errors: node_1.FileNode.getErrors(node),
+                node,
+            });
+        })
+            .on('fileCreated', async ({ uri }) => {
+            __classPrivateFieldGet(this, _Project_watchedFiles, "f").add(uri);
+            if (uri.endsWith(Project.RootSuffix)) {
+                this.updateRoots();
+            }
+            this.bind(uri);
+            return this.ensureParsedAndChecked(uri);
+        })
+            .on('fileModified', async ({ uri }) => {
+            if (this.isOnlyWatched(uri)) {
+                __classPrivateFieldGet(this, _Project_docAndNodes, "f").delete(uri);
+                await this.ensureParsedAndChecked(uri);
+            }
+        })
+            .on('fileDeleted', ({ uri }) => {
+            __classPrivateFieldGet(this, _Project_watchedFiles, "f").delete(uri);
+            if (uri.endsWith(Project.RootSuffix)) {
+                this.updateRoots();
+            }
+            this.symbols.clear({ uri });
+            this.tryClearingCache(uri);
+        });
+    }
+    /**
+     * 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() {
+        return __classPrivateFieldGet(this, _Project_roots, "f");
+    }
+    /**
+     * Arbitrary information that will be included in the `project` property of all `Context`s.
+     */
+    get ctx() {
+        return __classPrivateFieldGet(this, _Project_ctx, "f");
+    }
+    /**
+     * File path to a directory where all cache files of Spyglass should be stored.
+     */
+    get cacheRoot() {
+        return __classPrivateFieldGet(this, _Project_cacheRoot, "f");
+    }
+    updateRoots() {
+        const rawRoots = [...__classPrivateFieldGet(this, _Project_dependencyRoots, "f"), this.projectRoot];
+        const ans = new Set(rawRoots);
+        // Identify roots indicated by `pack.mcmeta`.
+        for (const file of this.getTrackedFiles()) {
+            if (file.endsWith(Project.RootSuffix) && rawRoots.some(r => file.startsWith(r))) {
+                ans.add(file.slice(0, 1 - Project.RootSuffix.length));
+            }
+        }
+        __classPrivateFieldSet(this, _Project_roots, [...ans].sort((a, b) => b.length - a.length), "f");
+        this.emit('rootsUpdated', { roots: __classPrivateFieldGet(this, _Project_roots, "f") });
+    }
+    /**
+     * 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() {
+        const extensions = this.meta.getSupportedFileExtensions();
+        return [...__classPrivateFieldGet(this, _Project_dependencyFiles, "f"), ...__classPrivateFieldGet(this, _Project_watchedFiles, "f")]
+            .filter(file => extensions.includes(fileUtil_1.fileUtil.extname(file) ?? ''));
+    }
+    setInitPromise() {
+        const loadConfig = async () => {
+            this.config = await __classPrivateFieldGet(this, _Project_configService, "f").load();
+        };
+        const callIntializers = async () => {
+            const initCtx = {
+                cacheRoot: this.cacheRoot,
+                config: this.config,
+                downloader: this.downloader,
+                logger: this.logger,
+                meta: this.meta,
+                projectRoot: this.projectRoot,
+            };
+            const results = await Promise.allSettled(__classPrivateFieldGet(this, _Project_initializers, "f").map(init => init(initCtx)));
+            let ctx = {};
+            results.forEach(async (r, i) => {
+                if (r.status === 'rejected') {
+                    this.logger.error(`[Project] [callInitializers] [${i}] “${__classPrivateFieldGet(this, _Project_initializers, "f")[i].name}”`, r.reason);
+                }
+                else if (r.value) {
+                    ctx = { ...ctx, ...r.value };
+                }
+            });
+            __classPrivateFieldSet(this, _Project_ctx, ctx, "f");
+        };
+        const init = async () => {
+            const __profiler = this.profilers.get('project#init');
+            const { symbols } = await this.cacheService.load();
+            this.symbols = new symbol_1.SymbolUtil(symbols);
+            this.symbols.buildCache();
+            __profiler.task('Load Cache');
+            await loadConfig();
+            __profiler.task('Load Config');
+            await callIntializers();
+            __profiler.task('Initialize').finalize();
+        };
+        __classPrivateFieldSet(this, _Project_initPromise, init(), "f");
+    }
+    setReadyPromise() {
+        const getDependencies = async () => {
+            const ans = [];
+            for (const dependency of this.config.env.dependencies) {
+                if (Dependency_1.DependencyKey.is(dependency)) {
+                    const provider = this.meta.getDependencyProvider(dependency);
+                    if (provider) {
+                        try {
+                            ans.push(await provider());
+                            this.logger.info(`[Project] [getDependencies] Executed provider “${dependency}”`);
+                        }
+                        catch (e) {
+                            this.logger.error(`[Project] [getDependencies] Bad provider “${dependency}”`, e);
+                        }
+                    }
+                    else {
+                        this.logger.error(`[Project] [getDependencies] Bad dependency “${dependency}”: no associated provider`);
+                    }
+                }
+                else {
+                    ans.push({ uri: dependency });
+                }
+            }
+            return ans;
+        };
+        const listDependencyFiles = async () => {
+            const dependencies = await getDependencies();
+            const fileUriSupporter = await FileService_1.FileUriSupporter.create(dependencies, this.logger);
+            const spyglassUriSupporter = await FileService_1.SpyglassUriSupporter.create(dependencies, this.logger, this.cacheService.checksums.roots);
+            this.fs.register('file:', fileUriSupporter, true);
+            this.fs.register(common_1.SpyglassUri.Protocol, spyglassUriSupporter, true);
+        };
+        const listProjectFiles = () => new Promise(resolve => {
+            __classPrivateFieldSet(this, _Project_watcherReady, false, "f");
+            __classPrivateFieldSet(this, _Project_watcher, chokidar_1.default
+                .watch(this.projectPath, { ignoreInitial: false })
+                .once('ready', () => {
+                __classPrivateFieldSet(this, _Project_watcherReady, true, "f");
+                resolve();
+            })
+                .on('add', path => {
+                const uri = fileUtil_1.fileUtil.pathToFileUri(path);
+                __classPrivateFieldGet(this, _Project_watchedFiles, "f").add(uri);
+                if (__classPrivateFieldGet(this, _Project_watcherReady, "f")) {
+                    this.emit('fileCreated', { uri });
+                }
+            })
+                .on('change', path => {
+                const uri = fileUtil_1.fileUtil.pathToFileUri(path);
+                if (__classPrivateFieldGet(this, _Project_watcherReady, "f")) {
+                    this.emit('fileModified', { uri });
+                }
+            })
+                .on('unlink', path => {
+                const uri = fileUtil_1.fileUtil.pathToFileUri(path);
+                __classPrivateFieldGet(this, _Project_watchedFiles, "f").delete(uri);
+                if (__classPrivateFieldGet(this, _Project_watcherReady, "f")) {
+                    this.emit('fileDeleted', { uri });
+                }
+            })
+                .on('error', e => {
+                this.logger.error('[Project] [chokidar]', e);
+            }), "f");
+        });
+        const ready = async () => {
+            await this.init();
+            const __profiler = this.profilers.get('project#ready');
+            const limit = (0, p_limit_1.default)(8);
+            const ensureParsed = this.ensureParsed.bind(this);
+            const ensureChecked = this.ensureChecked.bind(this);
+            await Promise.all([
+                listDependencyFiles(),
+                listProjectFiles(),
+            ]);
+            __classPrivateFieldSet(this, _Project_dependencyFiles, new Set(this.fs.listFiles()), "f");
+            __classPrivateFieldSet(this, _Project_dependencyRoots, new Set(this.fs.listRoots()), "f");
+            this.updateRoots();
+            __profiler.task('List Files');
+            for (const [id, { checksum, registrar }] of this.meta.symbolRegistrars) {
+                const cacheChecksum = this.cacheService.checksums.symbolRegistrars[id];
+                if (cacheChecksum === undefined || checksum !== cacheChecksum) {
+                    this.symbols.clear({ contributor: `symbol_registrar/${id}` });
+                    this.symbols.contributeAs(`symbol_registrar/${id}`, () => {
+                        registrar(this.symbols, { logger: this.logger });
+                    });
+                    this.emit('symbolRegistrarExecuted', { id, checksum });
+                }
+                else {
+                    this.logger.info(`[SymbolRegistrar] Skipped “${id}” thanks to cache ${checksum}`);
+                }
+            }
+            __profiler.task('Register Symbols');
+            const { addedFiles, changedFiles, removedFiles } = await this.cacheService.validate();
+            for (const uri of removedFiles) {
+                this.symbols.clear({ uri });
+            }
+            __profiler.task('Validate Cache');
+            if (addedFiles.length > 0) {
+                this.bind(addedFiles);
+            }
+            __profiler.task('Bind URIs');
+            const files = [...addedFiles, ...changedFiles]; // FIXME: nbtdoc files might need to be parsed and checked before others.
+            // const docAndNodes = (await Promise.all(files.map(uri => limit(ensureParsed, uri)))).filter((r): r is DocAndNode => !!r)
+            const docAndNodes = (await Promise.all(files.map(uri => ensureParsed(uri)))).filter((r) => !!r);
+            __profiler.task('Parse Files');
+            // await Promise.all(docAndNodes.map(({ doc, node }) => limit(ensureChecked, doc, node)))
+            await Promise.all(docAndNodes.map(({ doc, node }) => ensureChecked(doc, node)));
+            __profiler.task('Check Files').finalize();
+            this.emit('ready', {});
+        };
+        __classPrivateFieldSet(this, _Project_readyPromise, ready(), "f");
+    }
+    async init() {
+        await __classPrivateFieldGet(this, _Project_initPromise, "f");
+        return this;
+    }
+    async ready() {
+        await __classPrivateFieldGet(this, _Project_initPromise, "f");
+        await __classPrivateFieldGet(this, _Project_readyPromise, "f");
+        return this;
+    }
+    /**
+     * Behavior of the `Project` instance is undefined after this function has settled.
+     */
+    async close() {
+        clearInterval(__classPrivateFieldGet(this, _Project_cacheSaverIntervalId, "f"));
+        await __classPrivateFieldGet(this, _Project_watcher, "f").close();
+        await this.cacheService.save();
+    }
+    async restart() {
+        try {
+            await __classPrivateFieldGet(this, _Project_watcher, "f").close();
+            this.setReadyPromise();
+            await this.ready();
+        }
+        catch (e) {
+            this.logger.error('[Project#reset]', e);
+        }
+    }
+    resetCache() {
+        return this.cacheService.reset();
+    }
+    /**
+     * @returns The language ID of the file, or the file extension without the leading dot.
+     */
+    getLanguageID(uri) {
+        uri = fileUtil_1.fileUtil.normalize(uri);
+        const ext = fileUtil_1.fileUtil.extname(uri) ?? '.plaintext';
+        return this.meta.getLanguageID(ext) ?? ext.slice(1);
+    }
+    /**
+     * @returns The cached `TextDocument` and `AstNode` for the URI, or `undefined` when such data isn't available in cache.
+     */
+    get(uri) {
+        uri = fileUtil_1.fileUtil.normalize(uri);
+        return __classPrivateFieldGet(this, _Project_docAndNodes, "f").get(uri);
+    }
+    /**
+     * @throws FS-related errors
+     */
+    async ensureParsed(uri) {
+        uri = fileUtil_1.fileUtil.normalize(uri);
+        if (__classPrivateFieldGet(this, _Project_docAndNodes, "f").has(uri)) {
+            return __classPrivateFieldGet(this, _Project_docAndNodes, "f").get(uri);
+        }
+        const languageID = this.getLanguageID(uri);
+        if (!this.meta.isSupportedLanguage(languageID)) {
+            return undefined;
+        }
+        try {
+            const content = (0, common_1.bufferToString)(await this.fs.readFile(uri));
+            const doc = vscode_languageserver_textdocument_1.TextDocument.create(uri, languageID, -1, content);
+            return this.parseAndCache(doc);
+        }
+        catch (e) {
+            this.logger.warn(`[Project] [ensureParsed] Failed for “${uri}”`, e);
+            return undefined;
+        }
+    }
+    parseAndCache(doc) {
+        const node = this.parse(doc);
+        return this.cache(doc, node);
+    }
+    parse(doc) {
+        const ctx = Context_1.ParserContext.create(this, { doc });
+        const src = new source_1.Source(doc.getText());
+        let ans;
+        ctx.symbols.clear({ contributor: 'parser', uri: doc.uri });
+        ctx.symbols.contributeAs('parser', () => ans = (0, parser_1.file)()(src, ctx));
+        return ans;
+    }
+    cache(doc, node) {
+        const data = { doc, node };
+        __classPrivateFieldGet(this, _Project_docAndNodes, "f").set(doc.uri, data);
+        this.emit('documentUpdated', data);
+        return data;
+    }
+    async check(doc, node) {
+        const checker = this.meta.getChecker(node.type);
+        const ctx = Context_1.CheckerContext.create(this, { doc });
+        ctx.symbols.clear({ contributor: 'checker', uri: doc.uri });
+        await ctx.symbols.contributeAsAsync('checker', async () => {
+            await checker(node, ctx);
+            node.checkerErrors = ctx.err.dump();
+            this.cache(doc, node);
+            this.ensureLinted(doc, node);
+        });
+    }
+    async ensureChecked(doc, node) {
+        if (!node.checkerErrors) {
+            try {
+                return this.check(doc, node);
+            }
+            catch (e) {
+                this.logger.error(`[Project] [ensuredChecked] Failed for “${doc.uri}” #${doc.version}`, e);
+            }
+        }
+    }
+    lint(doc, node) {
+        node.linterErrors = [];
+        for (const [ruleName, rawValue] of Object.entries(this.config.lint)) {
+            const result = Config_1.LinterConfigValue.destruct(rawValue);
+            if (!result) {
+                // Rule is disabled (i.e. set to `null`) in the config.
+                continue;
+            }
+            const { ruleSeverity, ruleValue } = result;
+            const { configValidator, linter, nodePredicate } = this.meta.getLinter(ruleName);
+            if (!configValidator(ruleName, ruleValue, this.logger)) {
+                // Config value is invalid.
+                continue;
+            }
+            const ctx = Context_1.LinterContext.create(this, {
+                doc,
+                err: new ErrorReporter_1.LinterErrorReporter(ruleName, ruleSeverity),
+                ruleName,
+                ruleValue,
+            });
+            (0, processor_1.traversePreOrder)(node, () => true, () => true, node => {
+                if (nodePredicate(node)) {
+                    linter(node, ctx);
+                }
+            });
+            node.linterErrors.push(...ctx.err.dump());
+        }
+        this.cache(doc, node);
+    }
+    ensureLinted(doc, node) {
+        if (!node.linterErrors) {
+            try {
+                this.lint(doc, node);
+            }
+            catch (e) {
+                this.logger.error(`[Project] [ensureLinted] Failed for “${doc.uri}” #${doc.version}`, e);
+            }
+        }
+    }
+    async ensureParsedAndChecked(uri) {
+        const result = await this.ensureParsed(uri);
+        if (result) {
+            await this.ensureChecked(result.doc, result.node);
+        }
+        return result;
+    }
+    bind(param) {
+        const ctx = Context_1.UriBinderContext.create(this);
+        // Remove all symbol locations contributed by URI binders if the parameter is an array.
+        // Otherwise only remove the ones associated with the specified URI.
+        ctx.symbols.clear({ contributor: 'uri_binder', uri: Array.isArray(param) ? undefined : param });
+        ctx.symbols.contributeAs('uri_binder', () => {
+            const uris = Array.isArray(param) ? param : [param];
+            for (const binder of this.meta.uriBinders) {
+                binder(uris, ctx);
+            }
+        });
+    }
+    /**
+     * Notify that a new document was opened in the editor.
+     */
+    onDidOpen(uri, languageID, version, content) {
+        uri = fileUtil_1.fileUtil.normalize(uri);
+        __classPrivateFieldGet(this, _Project_clientManagedUris, "f").add(uri);
+        const doc = vscode_languageserver_textdocument_1.TextDocument.create(uri, languageID, version, content);
+        const { node } = this.parseAndCache(doc);
+        this.check(doc, node);
+    }
+    /**
+     * Notify that an existing document was changed in the editor.
+     * @throws If there is no `TextDocument` corresponding to the URI.
+     */
+    onDidChange(uri, changes, version) {
+        uri = fileUtil_1.fileUtil.normalize(uri);
+        const result = this.get(uri);
+        if (!result) {
+            throw new Error(`Document for “${uri}” is not cached. This should not happen. Did the language client send a didChange notification without sending a didOpen one?`);
+        }
+        vscode_languageserver_textdocument_1.TextDocument.update(result.doc, changes, version);
+        const { node } = this.parseAndCache(result.doc);
+        this.check(result.doc, node);
+    }
+    /**
+     * Notify that an existing document was closed in the editor.
+     */
+    onDidClose(uri) {
+        uri = fileUtil_1.fileUtil.normalize(uri);
+        __classPrivateFieldGet(this, _Project_clientManagedUris, "f").delete(uri);
+        this.tryClearingCache(uri);
+    }
+    async showCacheRoot() {
+        if (!__classPrivateFieldGet(this, _Project_cacheRoot, "f")) {
+            return;
+        }
+        try {
+            await fileUtil_1.fileUtil.showFile(__classPrivateFieldGet(this, _Project_cacheRoot, "f"));
+        }
+        catch (e) {
+            this.logger.error('[Service#showCacheRoot]', e);
+        }
+    }
+    tryClearingCache(uri) {
+        if (this.shouldRemove(uri)) {
+            __classPrivateFieldGet(this, _Project_docAndNodes, "f").delete(uri);
+            this.emit('documentRemoved', { uri });
+        }
+    }
+    shouldRemove(uri) {
+        return !__classPrivateFieldGet(this, _Project_clientManagedUris, "f").has(uri) && !__classPrivateFieldGet(this, _Project_dependencyFiles, "f").has(uri) && !__classPrivateFieldGet(this, _Project_watchedFiles, "f").has(uri);
+    }
+    isOnlyWatched(uri) {
+        return __classPrivateFieldGet(this, _Project_watchedFiles, "f").has(uri) && !__classPrivateFieldGet(this, _Project_clientManagedUris, "f").has(uri) && !__classPrivateFieldGet(this, _Project_dependencyFiles, "f").has(uri);
+    }
+}
+_Project_cacheSaverIntervalId = new WeakMap(), _Project_clientManagedUris = new WeakMap(), _Project_configService = new WeakMap(), _Project_docAndNodes = new WeakMap(), _Project_initializers = new WeakMap(), _Project_initPromise = new WeakMap(), _Project_readyPromise = new WeakMap(), _Project_watchedFiles = new WeakMap(), _Project_watcher = new WeakMap(), _Project_watcherReady = new WeakMap(), _Project_dependencyRoots = new WeakMap(), _Project_dependencyFiles = new WeakMap(), _Project_roots = new WeakMap(), _Project_ctx = new WeakMap(), _Project_cacheRoot = new WeakMap();
+Project.RootSuffix = '/pack.mcmeta';
+__decorate([
+    (0, common_1.CachePromise)()
+], Project.prototype, "ensureParsed", null);
+__decorate([
+    (0, common_1.CachePromise)()
+], Project.prototype, "check", null);
+__decorate([
+    (0, common_1.CachePromise)()
+], Project.prototype, "ensureChecked", null);
+__decorate([
+    (0, common_1.CachePromise)()
+], Project.prototype, "ensureParsedAndChecked", null);
+exports.Project = Project;
+//# sourceMappingURL=Project.js.map

package/lib/service/Service.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { FileNode } from '../node';
+import { AstNode } from '../node';
+import type { Color, ColorInfo, ColorToken, InlayHint, SignatureHelp } from '../processor';
+import { ColorPresentation } from '../processor';
+import { Range } from '../source';
+import type { SymbolUsageType } from '../symbol';
+import { Downloader } from './Downloader';
+import { FileService } from './FileService';
+import { Hover } from './Hover';
+import { Logger } from './Logger';
+import { ProfilerFactory } from './Profiler';
+import type { ProjectInitializer } from './Project';
+import { Project } from './Project';
+import { SymbolLocations } from './SymbolLocations';
+interface Options {
+    cacheRoot: string;
+    downloader?: Downloader;
+    fs?: FileService;
+    initializers?: readonly ProjectInitializer[];
+    isDebugging?: boolean;
+    logger?: Logger;
+    profilers?: ProfilerFactory;
+    projectPath: string;
+}
+export declare class Service extends EventEmitter {
+    readonly downloader: Downloader;
+    readonly fs: FileService;
+    readonly isDebugging: boolean;
+    readonly logger: Logger;
+    readonly profilers: ProfilerFactory;
+    readonly project: Project;
+    constructor({ cacheRoot, downloader, fs, initializers, isDebugging, logger, profilers, projectPath, }: Options);
+    private debug;
+    colorize(node: FileNode<AstNode>, doc: TextDocument, range?: Range): readonly ColorToken[];
+    getColorInfo(node: FileNode<AstNode>, doc: TextDocument): ColorInfo[];
+    getColorPresentation(file: FileNode<AstNode>, doc: TextDocument, range: Range, color: Color): ColorPresentation[];
+    complete(node: FileNode<AstNode>, doc: TextDocument, offset: number, triggerCharacter?: string): import("../processor").CompletionItem[];
+    dataHackPubify(initialism: string): string;
+    getHover(file: FileNode<AstNode>, doc: TextDocument, offset: number): Hover | undefined;
+    getInlayHints(node: FileNode<AstNode>, doc: TextDocument, range?: Range): InlayHint[];
+    getSignatureHelp(node: FileNode<AstNode>, doc: TextDocument, offset: number): SignatureHelp | undefined;
+    /**
+     * @param searchedUsages Type of symbol usages that should be included in the result. Defaults to all usages.
+     * @param currentFileOnly Whether only symbol locations in the current file should be returned.
+     *
+     * @returns Symbol locations of the selected symbol at `offset`, or `undefined` if there's no symbol at `offset`.
+     */
+    getSymbolLocations(file: FileNode<AstNode>, doc: TextDocument, offset: number, searchedUsages?: readonly SymbolUsageType[], currentFileOnly?: boolean): SymbolLocations | undefined;
+    format(node: FileNode<AstNode>, doc: TextDocument, tabSize: number, insertSpaces: boolean): string;
+}
+export {};
+//# sourceMappingURL=Service.d.ts.map