@codingame/monaco-vscode-treesitter-service-override 17.2.0 → 18.0.0

package/vscode/src/vs/editor/common/services/treeSitter/treeSitterLanguages.d.ts

@@ -1,31 +0,0 @@
-import type * as Parser from "@vscode/tree-sitter-wasm";
-import { AppResourcePath } from "@codingame/monaco-vscode-api/vscode/vs/base/common/network";
-import { ITreeSitterImporter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
-import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-export declare const MODULE_LOCATION_SUBPATH = "@vscode/tree-sitter-wasm/wasm";
-export declare function getModuleLocation(environmentService: IEnvironmentService): AppResourcePath;
-export declare class TreeSitterLanguages extends Disposable {
-    private readonly _treeSitterImporter;
-    private readonly _fileService;
-    private readonly _environmentService;
-    private readonly _registeredLanguages;
-    private _languages;
-    readonly _onDidAddLanguage: Emitter<{
-        id: string;
-        language: Parser.Language;
-    }>;
-    readonly onDidAddLanguage: Event<{
-        id: string;
-        language: Parser.Language;
-    }>;
-    constructor(_treeSitterImporter: ITreeSitterImporter, _fileService: IFileService, _environmentService: IEnvironmentService, configurationService: IConfigurationService, _registeredLanguages: Map<string, string>);
-    getOrInitLanguage(languageId: string): Parser.Language | undefined;
-    getLanguage(languageId: string): Promise<Parser.Language | undefined>;
-    private _addLanguage;
-    private _fetchLanguage;
-    private _getLanguageLocation;
-}

package/vscode/src/vs/editor/common/services/treeSitter/treeSitterLanguages.js

@@ -1,120 +0,0 @@
-
-import { nodeModulesPath, FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { EDITOR_EXPERIMENTAL_PREFER_TREESITTER } from '../treeSitterParserService.js';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { PromiseResult } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/promise';
-
-const MODULE_LOCATION_SUBPATH = `@vscode/tree-sitter-wasm/wasm`;
-function getModuleLocation(environmentService) {
-    return `${nodeModulesPath}/${MODULE_LOCATION_SUBPATH}`;
-}
-class TreeSitterLanguages extends Disposable {
-    constructor(_treeSitterImporter, _fileService, _environmentService, configurationService, _registeredLanguages) {
-        super();
-        this._treeSitterImporter = _treeSitterImporter;
-        this._fileService = _fileService;
-        this._environmentService = _environmentService;
-        this._registeredLanguages = _registeredLanguages;
-        this._languages = ( new AsyncCache());
-        this._onDidAddLanguage = this._register(( new Emitter()));
-        this.onDidAddLanguage = this._onDidAddLanguage.event;
-        this._register(configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(EDITOR_EXPERIMENTAL_PREFER_TREESITTER)) {
-                for (const language of ( this._languages.keys())) {
-                    if (e.affectsConfiguration(`${EDITOR_EXPERIMENTAL_PREFER_TREESITTER}.${language}`)) {
-                        if (this._languages.getSyncIfCached(language) === undefined) {
-                            this._languages.delete(language);
-                        }
-                    }
-                }
-            }
-        }));
-    }
-    getOrInitLanguage(languageId) {
-        if (this._languages.isCached(languageId)) {
-            return this._languages.getSyncIfCached(languageId);
-        }
-        else {
-            this._addLanguage(languageId);
-            return undefined;
-        }
-    }
-    async getLanguage(languageId) {
-        if (this._languages.isCached(languageId)) {
-            return this._languages.getSyncIfCached(languageId);
-        }
-        else {
-            await this._addLanguage(languageId);
-            return this._languages.get(languageId);
-        }
-    }
-    async _addLanguage(languageId) {
-        const languagePromise = this._languages.get(languageId);
-        if (!languagePromise) {
-            this._languages.set(languageId, this._fetchLanguage(languageId));
-            const language = await this._languages.get(languageId);
-            if (!language) {
-                return undefined;
-            }
-            this._onDidAddLanguage.fire({ id: languageId, language });
-        }
-    }
-    async _fetchLanguage(languageId) {
-        const grammarName = this._registeredLanguages.get(languageId);
-        const languageLocation = this._getLanguageLocation(languageId);
-        if (!grammarName || !languageLocation) {
-            return undefined;
-        }
-        const wasmPath = `${languageLocation}/${grammarName}.wasm`;
-        const languageFile = await (this._fileService.readFile(( FileAccess.asFileUri(wasmPath))));
-        const Language = await this._treeSitterImporter.getLanguageClass();
-        return Language.load(languageFile.value.buffer);
-    }
-    _getLanguageLocation(languageId) {
-        const grammarName = this._registeredLanguages.get(languageId);
-        if (!grammarName) {
-            return undefined;
-        }
-        return getModuleLocation();
-    }
-}
-class AsyncCache {
-    constructor() {
-        this._values = ( new Map());
-    }
-    set(key, promise) {
-        this._values.set(key, ( new PromiseWithSyncAccess(promise)));
-    }
-    get(key) {
-        return this._values.get(key)?.promise;
-    }
-    getSyncIfCached(key) {
-        return this._values.get(key)?.result?.data;
-    }
-    isCached(key) {
-        return this._values.get(key)?.result !== undefined;
-    }
-    delete(key) {
-        return this._values.delete(key);
-    }
-    keys() {
-        return ( this._values.keys());
-    }
-}
-class PromiseWithSyncAccess {
-    get result() {
-        return this._result;
-    }
-    constructor(promise) {
-        this.promise = promise;
-        promise.then(result => {
-            this._result = ( new PromiseResult(result, undefined));
-        }).catch(e => {
-            this._result = ( new PromiseResult(undefined, e));
-        });
-    }
-}
-
-export { MODULE_LOCATION_SUBPATH, TreeSitterLanguages, getModuleLocation };

package/vscode/src/vs/editor/common/services/treeSitter/treeSitterParserService.d.ts

@@ -1,48 +0,0 @@
-import type * as Parser from "@vscode/tree-sitter-wasm";
-import { ITextModelTreeSitter, TreeUpdateEvent } from "../treeSitterParserService.js";
-import { ITreeSitterImporter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
-import { ITreeSitterParserService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
-import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
-import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-export declare class TreeSitterTextModelService extends Disposable implements ITreeSitterParserService {
-    private readonly _modelService;
-    private readonly _configurationService;
-    private readonly _environmentService;
-    private readonly _treeSitterImporter;
-    private readonly _instantiationService;
-    readonly _serviceBrand: undefined;
-    private _init;
-    private _textModelTreeSitters;
-    private readonly _registeredLanguages;
-    private readonly _treeSitterLanguages;
-    readonly onDidAddLanguage: Event<{
-        id: string;
-        language: Parser.Language;
-    }>;
-    private _onDidUpdateTree;
-    readonly onDidUpdateTree: Event<TreeUpdateEvent>;
-    isTest: boolean;
-    constructor(_modelService: IModelService, fileService: IFileService, _configurationService: IConfigurationService, _environmentService: IEnvironmentService, _treeSitterImporter: ITreeSitterImporter, _instantiationService: IInstantiationService);
-    getOrInitLanguage(languageId: string): Parser.Language | undefined;
-    getParseResult(textModel: ITextModel): ITextModelTreeSitter | undefined;
-    getTree(content: string, languageId: string): Promise<Parser.Tree | undefined>;
-    getTreeSync(content: string, languageId: string): Parser.Tree | undefined;
-    getLanguage(languageId: string): Promise<Parser.Language | undefined>;
-    private _doInitParser;
-    private _hasInit;
-    private _initParser;
-    private _supportedLanguagesChanged;
-    private _getSetting;
-    private _registerModelServiceListeners;
-    getTextModelTreeSitter(model: ITextModel, parseImmediately?: boolean): Promise<ITextModelTreeSitter>;
-    private _createTextModelTreeSitter;
-    private _handleOnDidChangeParseResult;
-    private _addGrammar;
-    private _removeGrammar;
-}

package/vscode/src/vs/editor/common/services/treeSitter/treeSitterParserService.js

@@ -1,179 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { EDITOR_EXPERIMENTAL_PREFER_TREESITTER, TREESITTER_ALLOWED_SUPPORT } from '../treeSitterParserService.js';
-import { ITreeSitterImporter } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service';
-import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
-import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
-import { TextModelTreeSitter } from './textModelTreeSitter.js';
-import { TreeSitterLanguages, getModuleLocation } from './treeSitterLanguages.js';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-
-const EDITOR_TREESITTER_TELEMETRY = 'editor.experimental.treeSitterTelemetry';
-const FILENAME_TREESITTER_WASM = `tree-sitter.wasm`;
-let TreeSitterTextModelService = class TreeSitterTextModelService extends Disposable {
-    constructor(_modelService, fileService, _configurationService, _environmentService, _treeSitterImporter, _instantiationService) {
-        super();
-        this._modelService = _modelService;
-        this._configurationService = _configurationService;
-        this._environmentService = _environmentService;
-        this._treeSitterImporter = _treeSitterImporter;
-        this._instantiationService = _instantiationService;
-        this._textModelTreeSitters = this._register(( new DisposableMap()));
-        this._registeredLanguages = ( new Map());
-        this._onDidUpdateTree = this._register(( new Emitter()));
-        this.onDidUpdateTree = this._onDidUpdateTree.event;
-        this.isTest = false;
-        this._hasInit = false;
-        this._treeSitterLanguages = this._register(( new TreeSitterLanguages(
-            this._treeSitterImporter,
-            fileService,
-            this._environmentService,
-            this._configurationService,
-            this._registeredLanguages
-        )));
-        this.onDidAddLanguage = this._treeSitterLanguages.onDidAddLanguage;
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(EDITOR_EXPERIMENTAL_PREFER_TREESITTER)) {
-                this._supportedLanguagesChanged();
-            }
-        }));
-        this._supportedLanguagesChanged();
-    }
-    getOrInitLanguage(languageId) {
-        return this._treeSitterLanguages.getOrInitLanguage(languageId);
-    }
-    getParseResult(textModel) {
-        const textModelTreeSitter = this._textModelTreeSitters.get(textModel);
-        return textModelTreeSitter?.textModelTreeSitter;
-    }
-    async getTree(content, languageId) {
-        const language = await this.getLanguage(languageId);
-        const Parser = await this._treeSitterImporter.getParserClass();
-        if (language) {
-            const parser = ( new Parser());
-            parser.setLanguage(language);
-            return parser.parse(content) ?? undefined;
-        }
-        return undefined;
-    }
-    getTreeSync(content, languageId) {
-        const language = this.getOrInitLanguage(languageId);
-        const Parser = this._treeSitterImporter.parserClass;
-        if (language && Parser) {
-            const parser = ( new Parser());
-            parser.setLanguage(language);
-            return parser.parse(content) ?? undefined;
-        }
-        return undefined;
-    }
-    async getLanguage(languageId) {
-        await this._init;
-        return this._treeSitterLanguages.getLanguage(languageId);
-    }
-    async _doInitParser() {
-        const Parser = await this._treeSitterImporter.getParserClass();
-        const isTest = this.isTest;
-        await Parser.init({
-            locateFile(_file, _folder) {
-                const location = `${getModuleLocation()}/${FILENAME_TREESITTER_WASM}`;
-                if (isTest) {
-                    return ( ( FileAccess.asFileUri(location)).toString(true));
-                }
-                else {
-                    return ( ( FileAccess.asBrowserUri(location)).toString(true));
-                }
-            }
-        });
-        return true;
-    }
-    async _initParser(hasLanguages) {
-        if (this._hasInit) {
-            return this._init;
-        }
-        if (hasLanguages) {
-            this._hasInit = true;
-            this._init = this._doInitParser();
-            this._init.then(() => this._registerModelServiceListeners());
-        }
-        else {
-            this._init = Promise.resolve(false);
-        }
-        return this._init;
-    }
-    async _supportedLanguagesChanged() {
-        let hasLanguages = false;
-        const handleLanguage = (languageId) => {
-            if (this._getSetting(languageId)) {
-                hasLanguages = true;
-                this._addGrammar(languageId, `tree-sitter-${languageId}`);
-            }
-            else {
-                this._removeGrammar(languageId);
-            }
-        };
-        for (const languageId of TREESITTER_ALLOWED_SUPPORT) {
-            handleLanguage(languageId);
-        }
-        return this._initParser(hasLanguages);
-    }
-    _getSetting(languageId) {
-        const setting = this._configurationService.getValue(`${EDITOR_EXPERIMENTAL_PREFER_TREESITTER}.${languageId}`);
-        if (!setting && TREESITTER_ALLOWED_SUPPORT.includes(languageId)) {
-            return this._configurationService.getValue(EDITOR_TREESITTER_TELEMETRY);
-        }
-        return setting;
-    }
-    async _registerModelServiceListeners() {
-        this._register(this._modelService.onModelAdded(model => {
-            this._createTextModelTreeSitter(model);
-        }));
-        this._register(this._modelService.onModelRemoved(model => {
-            this._textModelTreeSitters.deleteAndDispose(model);
-        }));
-        this._modelService.getModels().forEach(model => this._createTextModelTreeSitter(model));
-    }
-    async getTextModelTreeSitter(model, parseImmediately = false) {
-        await this.getLanguage(model.getLanguageId());
-        return this._createTextModelTreeSitter(model, parseImmediately);
-    }
-    _createTextModelTreeSitter(model, parseImmediately = true) {
-        const textModelTreeSitter = this._instantiationService.createInstance(TextModelTreeSitter, model, this._treeSitterLanguages, parseImmediately);
-        const disposables = ( new DisposableStore());
-        disposables.add(textModelTreeSitter);
-        disposables.add(textModelTreeSitter.onDidChangeParseResult((e) => this._handleOnDidChangeParseResult(e, model)));
-        this._textModelTreeSitters.set(model, {
-            textModelTreeSitter,
-            disposables,
-            dispose: disposables.dispose.bind(disposables)
-        });
-        return textModelTreeSitter;
-    }
-    _handleOnDidChangeParseResult(change, model) {
-        this._onDidUpdateTree.fire({ textModel: model, ranges: change.ranges, versionId: change.versionId, tree: change.tree, languageId: change.languageId, hasInjections: change.hasInjections });
-    }
-    _addGrammar(languageId, grammarName) {
-        if (!( this._registeredLanguages.has(languageId))) {
-            this._registeredLanguages.set(languageId, grammarName);
-        }
-    }
-    _removeGrammar(languageId) {
-        if (( this._registeredLanguages.has(languageId))) {
-            this._registeredLanguages.delete(languageId);
-        }
-    }
-};
-TreeSitterTextModelService = ( __decorate([
-    ( __param(0, IModelService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEnvironmentService)),
-    ( __param(4, ITreeSitterImporter)),
-    ( __param(5, IInstantiationService))
-], TreeSitterTextModelService));
-
-export { TreeSitterTextModelService };

package/vscode/src/vs/editor/common/services/treeSitterParserService.d.ts

@@ -1,61 +0,0 @@
-import type * as Parser from "@vscode/tree-sitter-wasm";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
-import { IModelContentChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEvents";
-import { ITreeSitterImporter } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
-export declare const EDITOR_EXPERIMENTAL_PREFER_TREESITTER = "editor.experimental.preferTreeSitter";
-export declare const TREESITTER_ALLOWED_SUPPORT: string[];
-export interface RangeWithOffsets {
-    range: Range;
-    startOffset: number;
-    endOffset: number;
-}
-export interface RangeChange {
-    newRange: Range;
-    newRangeStartOffset: number;
-    newRangeEndOffset: number;
-}
-export interface TreeParseUpdateEvent {
-    ranges: RangeChange[] | undefined;
-    language: string;
-    versionId: number;
-    tree: Parser.Tree;
-    includedModelChanges: IModelContentChangedEvent[];
-}
-export interface ModelTreeUpdateEvent {
-    ranges: RangeChange[];
-    versionId: number;
-    tree: ITextModelTreeSitter;
-    languageId: string;
-    hasInjections: boolean;
-}
-export interface TreeUpdateEvent extends ModelTreeUpdateEvent {
-    textModel: ITextModel;
-}
-export interface ITreeSitterParseResult {
-    readonly tree: Parser.Tree | undefined;
-    readonly language: Parser.Language;
-    readonly languageId: string;
-    readonly ranges: Parser.Range[] | undefined;
-    versionId: number;
-}
-export interface ITextModelTreeSitter {
-    parse(languageId?: string): Promise<ITreeSitterParseResult | undefined>;
-    textModel: ITextModel;
-    parseResult: ITreeSitterParseResult | undefined;
-    getInjection(offset: number, parentLanguage: string): ITreeSitterParseResult | undefined;
-    dispose(): void;
-}
-export declare class TreeSitterImporter implements ITreeSitterImporter {
-    readonly _serviceBrand: undefined;
-    private _treeSitterImport;
-    constructor();
-    private _getTreeSitterImport;
-    get parserClass(): typeof Parser.Parser | undefined;
-    private _parserClass;
-    getParserClass(): Promise<typeof Parser.Parser>;
-    private _languageClass;
-    getLanguageClass(): Promise<typeof Parser.Language>;
-    private _queryClass;
-    getQueryClass(): Promise<typeof Parser.Query>;
-}

package/vscode/src/vs/editor/common/services/treeSitterParserService.js

@@ -1,36 +0,0 @@
-
-
-const EDITOR_EXPERIMENTAL_PREFER_TREESITTER = 'editor.experimental.preferTreeSitter';
-const TREESITTER_ALLOWED_SUPPORT = ['css', 'typescript', 'ini', 'regex'];
-class TreeSitterImporter {
-    constructor() { }
-    async _getTreeSitterImport() {
-        if (!this._treeSitterImport) {
-            this._treeSitterImport = await import('@vscode/tree-sitter-wasm').then(module => ({ Parser: module.default ?? module }));
-        }
-        return this._treeSitterImport;
-    }
-    get parserClass() {
-        return this._parserClass;
-    }
-    async getParserClass() {
-        if (!this._parserClass) {
-            this._parserClass = (await this._getTreeSitterImport()).Parser;
-        }
-        return this._parserClass;
-    }
-    async getLanguageClass() {
-        if (!this._languageClass) {
-            this._languageClass = (await this._getTreeSitterImport()).Language;
-        }
-        return this._languageClass;
-    }
-    async getQueryClass() {
-        if (!this._queryClass) {
-            this._queryClass = (await this._getTreeSitterImport()).Query;
-        }
-        return this._queryClass;
-    }
-}
-
-export { EDITOR_EXPERIMENTAL_PREFER_TREESITTER, TREESITTER_ALLOWED_SUPPORT, TreeSitterImporter };

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterCodeEditors.d.ts

@@ -1,32 +0,0 @@
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
-import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
-import { ITreeSitterParserService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service";
-export interface IViewPortChangeEvent {
-    model: ITextModel;
-    ranges: Range[];
-}
-export declare class TreeSitterCodeEditors extends Disposable {
-    private readonly _languageId;
-    private readonly _codeEditorService;
-    private readonly _treeSitterParserService;
-    private readonly _textModels;
-    private readonly _languageEditors;
-    private readonly _allEditors;
-    private readonly _onDidChangeViewport;
-    readonly onDidChangeViewport: Event<IViewPortChangeEvent>;
-    constructor(_languageId: string, _codeEditorService: ICodeEditorService, _treeSitterParserService: ITreeSitterParserService);
-    get textModels(): ITextModel[];
-    getEditorForModel(model: ITextModel): ICodeEditor | undefined;
-    getInitialViewPorts(): Promise<IViewPortChangeEvent[]>;
-    private _onCodeEditorRemove;
-    private getEditorModel;
-    private _onCodeEditorAdd;
-    private _tryAddEditor;
-    private _onDidChangeModel;
-    private _onViewportChange;
-    private _nonIntersectingViewPortRanges;
-}

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterCodeEditors.js

@@ -1,119 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
-import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { ITreeSitterParserService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service';
-
-let TreeSitterCodeEditors = class TreeSitterCodeEditors extends Disposable {
-    constructor(_languageId, _codeEditorService, _treeSitterParserService) {
-        super();
-        this._languageId = _languageId;
-        this._codeEditorService = _codeEditorService;
-        this._treeSitterParserService = _treeSitterParserService;
-        this._textModels = ( new Set());
-        this._languageEditors = this._register(( new DisposableMap()));
-        this._allEditors = this._register(( new DisposableMap()));
-        this._onDidChangeViewport = this._register(( new Emitter()));
-        this.onDidChangeViewport = this._onDidChangeViewport.event;
-        this._register(this._codeEditorService.onCodeEditorAdd(this._onCodeEditorAdd, this));
-        this._register(this._codeEditorService.onCodeEditorRemove(this._onCodeEditorRemove, this));
-        this._codeEditorService.listCodeEditors().forEach(this._onCodeEditorAdd, this);
-    }
-    get textModels() {
-        return Array.from(( this._textModels.keys()));
-    }
-    getEditorForModel(model) {
-        return this._codeEditorService.listCodeEditors().find(editor => editor.getModel() === model);
-    }
-    async getInitialViewPorts() {
-        await this._treeSitterParserService.getLanguage(this._languageId);
-        const editors = this._codeEditorService.listCodeEditors();
-        const viewports = [];
-        for (const editor of editors) {
-            const model = await this.getEditorModel(editor);
-            if (model && model.getLanguageId() === this._languageId) {
-                viewports.push({
-                    model,
-                    ranges: this._nonIntersectingViewPortRanges(editor)
-                });
-            }
-        }
-        return viewports;
-    }
-    _onCodeEditorRemove(editor) {
-        this._allEditors.deleteAndDispose(editor);
-    }
-    async getEditorModel(editor) {
-        let model = editor.getModel() ?? undefined;
-        if (!model) {
-            const disposableStore = this._register(( new DisposableStore()));
-            await Event.toPromise(Event.once(editor.onDidChangeModel), disposableStore);
-            model = editor.getModel() ?? undefined;
-        }
-        return model;
-    }
-    async _onCodeEditorAdd(editor) {
-        const otherEditorDisposables = ( new DisposableStore());
-        otherEditorDisposables.add(editor.onDidChangeModel(() => this._onDidChangeModel(editor, editor.getModel()), this));
-        this._allEditors.set(editor, otherEditorDisposables);
-        const model = editor.getModel();
-        if (model) {
-            this._tryAddEditor(editor, model);
-        }
-    }
-    _tryAddEditor(editor, model) {
-        const language = model.getLanguageId();
-        if ((language === this._languageId)) {
-            if (!( this._textModels.has(model))) {
-                this._textModels.add(model);
-            }
-            if (!( this._languageEditors.has(editor))) {
-                const langaugeEditorDisposables = ( new DisposableStore());
-                langaugeEditorDisposables.add(editor.onDidScrollChange(() => this._onViewportChange(editor), this));
-                this._languageEditors.set(editor, langaugeEditorDisposables);
-                this._onViewportChange(editor);
-            }
-        }
-    }
-    async _onDidChangeModel(editor, model) {
-        if (model) {
-            this._tryAddEditor(editor, model);
-        }
-        else {
-            this._languageEditors.deleteAndDispose(editor);
-        }
-    }
-    async _onViewportChange(editor) {
-        const ranges = this._nonIntersectingViewPortRanges(editor);
-        const model = editor.getModel();
-        if (!model) {
-            this._languageEditors.deleteAndDispose(editor);
-            return;
-        }
-        this._onDidChangeViewport.fire({ model: model, ranges });
-    }
-    _nonIntersectingViewPortRanges(editor) {
-        const viewportRanges = editor.getVisibleRangesPlusViewportAboveBelow();
-        const nonIntersectingRanges = [];
-        for (const range of viewportRanges) {
-            if (nonIntersectingRanges.length !== 0) {
-                const prev = nonIntersectingRanges[nonIntersectingRanges.length - 1];
-                if (Range.areOnlyIntersecting(prev, range)) {
-                    const newRange = prev.plusRange(range);
-                    nonIntersectingRanges[nonIntersectingRanges.length - 1] = newRange;
-                    continue;
-                }
-            }
-            nonIntersectingRanges.push(range);
-        }
-        return nonIntersectingRanges;
-    }
-};
-TreeSitterCodeEditors = ( __decorate([
-    ( __param(1, ICodeEditorService)),
-    ( __param(2, ITreeSitterParserService))
-], TreeSitterCodeEditors));
-
-export { TreeSitterCodeEditors };

package/vscode/src/vs/workbench/services/treeSitter/browser/treeSitterTokenizationFeature.contribution.d.ts

@@ -1 +0,0 @@
-export {};