@codingame/monaco-vscode-api 14.0.6 → 15.0.0

package/vscode/src/vs/editor/browser/widget/diffEditor/diffProviderFactoryService.js

@@ -1,127 +0,0 @@
-
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { registerSingleton, InstantiationType } from '../../../../platform/instantiation/common/extensions.js';
-import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { StopWatch } from '../../../../base/common/stopwatch.js';
-import { LineRange } from '../../../common/core/lineRange.js';
-import { DetailedLineRangeMapping, RangeMapping } from '../../../common/diff/rangeMapping.js';
-import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
-
-var WorkerBasedDocumentDiffProvider_1;
-const IDiffProviderFactoryService = ( createDecorator('diffProviderFactoryService'));
-let WorkerBasedDiffProviderFactoryService = class WorkerBasedDiffProviderFactoryService {
-    constructor(instantiationService) {
-        this.instantiationService = instantiationService;
-    }
-    createDiffProvider(options) {
-        return this.instantiationService.createInstance(WorkerBasedDocumentDiffProvider, options);
-    }
-};
-WorkerBasedDiffProviderFactoryService = ( __decorate([
-    ( __param(0, IInstantiationService))
-], WorkerBasedDiffProviderFactoryService));
-registerSingleton(IDiffProviderFactoryService, WorkerBasedDiffProviderFactoryService, InstantiationType.Delayed);
-let WorkerBasedDocumentDiffProvider = class WorkerBasedDocumentDiffProvider {
-    static { WorkerBasedDocumentDiffProvider_1 = this; }
-    static { this.diffCache = ( new Map()); }
-    constructor(options, editorWorkerService, telemetryService) {
-        this.editorWorkerService = editorWorkerService;
-        this.telemetryService = telemetryService;
-        this.onDidChangeEventEmitter = ( new Emitter());
-        this.onDidChange = this.onDidChangeEventEmitter.event;
-        this.diffAlgorithm = 'advanced';
-        this.diffAlgorithmOnDidChangeSubscription = undefined;
-        this.setOptions(options);
-    }
-    dispose() {
-        this.diffAlgorithmOnDidChangeSubscription?.dispose();
-    }
-    async computeDiff(original, modified, options, cancellationToken) {
-        if (typeof this.diffAlgorithm !== 'string') {
-            return this.diffAlgorithm.computeDiff(original, modified, options, cancellationToken);
-        }
-        if (original.isDisposed() || modified.isDisposed()) {
-            return {
-                changes: [],
-                identical: true,
-                quitEarly: false,
-                moves: [],
-            };
-        }
-        if (original.getLineCount() === 1 && original.getLineMaxColumn(1) === 1) {
-            if (modified.getLineCount() === 1 && modified.getLineMaxColumn(1) === 1) {
-                return {
-                    changes: [],
-                    identical: true,
-                    quitEarly: false,
-                    moves: [],
-                };
-            }
-            return {
-                changes: [
-                    ( new DetailedLineRangeMapping(( new LineRange(1, 2)), ( new LineRange(1, modified.getLineCount() + 1)), [
-                        ( new RangeMapping(original.getFullModelRange(), modified.getFullModelRange()))
-                    ]))
-                ],
-                identical: false,
-                quitEarly: false,
-                moves: [],
-            };
-        }
-        const uriKey = JSON.stringify([( original.uri.toString()), ( modified.uri.toString())]);
-        const context = JSON.stringify([original.id, modified.id, original.getAlternativeVersionId(), modified.getAlternativeVersionId(), JSON.stringify(options)]);
-        const c = WorkerBasedDocumentDiffProvider_1.diffCache.get(uriKey);
-        if (c && c.context === context) {
-            return c.result;
-        }
-        const sw = StopWatch.create();
-        const result = await this.editorWorkerService.computeDiff(original.uri, modified.uri, options, this.diffAlgorithm);
-        const timeMs = sw.elapsed();
-        this.telemetryService.publicLog2('diffEditor.computeDiff', {
-            timeMs,
-            timedOut: result?.quitEarly ?? true,
-            detectedMoves: options.computeMoves ? (result?.moves.length ?? 0) : -1,
-        });
-        if (cancellationToken.isCancellationRequested) {
-            return {
-                changes: [],
-                identical: false,
-                quitEarly: true,
-                moves: [],
-            };
-        }
-        if (!result) {
-            throw ( new Error('no diff result available'));
-        }
-        if (WorkerBasedDocumentDiffProvider_1.diffCache.size > 10) {
-            WorkerBasedDocumentDiffProvider_1.diffCache.delete(( WorkerBasedDocumentDiffProvider_1.diffCache.keys()).next().value);
-        }
-        WorkerBasedDocumentDiffProvider_1.diffCache.set(uriKey, { result, context });
-        return result;
-    }
-    setOptions(newOptions) {
-        let didChange = false;
-        if (newOptions.diffAlgorithm) {
-            if (this.diffAlgorithm !== newOptions.diffAlgorithm) {
-                this.diffAlgorithmOnDidChangeSubscription?.dispose();
-                this.diffAlgorithmOnDidChangeSubscription = undefined;
-                this.diffAlgorithm = newOptions.diffAlgorithm;
-                if (typeof newOptions.diffAlgorithm !== 'string') {
-                    this.diffAlgorithmOnDidChangeSubscription = newOptions.diffAlgorithm.onDidChange(() => this.onDidChangeEventEmitter.fire());
-                }
-                didChange = true;
-            }
-        }
-        if (didChange) {
-            this.onDidChangeEventEmitter.fire();
-        }
-    }
-};
-WorkerBasedDocumentDiffProvider = WorkerBasedDocumentDiffProvider_1 = ( __decorate([
-    ( __param(1, IEditorWorkerService)),
-    ( __param(2, ITelemetryService))
-], WorkerBasedDocumentDiffProvider));
-
-export { IDiffProviderFactoryService, WorkerBasedDiffProviderFactoryService, WorkerBasedDocumentDiffProvider };

package/vscode/src/vs/editor/common/model/tokenStore.d.ts

@@ -1,59 +0,0 @@
-import { IDisposable } from "../../../base/common/lifecycle.js";
-import { ITextModel } from "../model.js";
-declare class ListNode implements IDisposable {
-    readonly height: number;
-    parent?: ListNode;
-    private readonly _children;
-    get children(): ReadonlyArray<Node>;
-    private _length;
-    get length(): number;
-    constructor(height: number);
-    static create(node1: Node, node2: Node): ListNode;
-    canAppendChild(): boolean;
-    appendChild(node: Node): void;
-    private _updateParentLength;
-    unappendChild(): Node;
-    prependChild(node: Node): void;
-    unprependChild(): Node;
-    lastChild(): Node;
-    dispose(): void;
-}
-type Node = ListNode | LeafNode;
-interface LeafNode {
-    readonly length: number;
-    parent?: ListNode;
-    token: number;
-    needsRefresh?: boolean;
-    height: 0;
-}
-export interface TokenUpdate {
-    readonly startOffsetInclusive: number;
-    readonly length: number;
-    readonly token: number;
-}
-export declare class TokenStore implements IDisposable {
-    private readonly _textModel;
-    private _root;
-    get root(): Node;
-    constructor(_textModel: ITextModel);
-    private createEmptyRoot;
-    buildStore(tokens: TokenUpdate[]): void;
-    private createFromUpdates;
-    update(length: number, tokens: TokenUpdate[], needsRefresh?: boolean): void;
-    delete(length: number, startOffset: number): void;
-    private replace;
-    private traverseInOrderInRange;
-    getTokenAt(offset: number): TokenUpdate | undefined;
-    getTokensInRange(startOffsetInclusive: number, endOffsetExclusive: number): TokenUpdate[];
-    markForRefresh(startOffsetInclusive: number, endOffsetExclusive: number): void;
-    rangeNeedsRefresh(startOffsetInclusive: number, endOffsetExclusive: number): boolean;
-    getNeedsRefresh(): {
-        startOffset: number;
-        endOffset: number;
-    }[];
-    deepCopy(): TokenStore;
-    private _copyNodeIterative;
-    printTree(root?: Node): string;
-    dispose(): void;
-}
-export {};

package/vscode/src/vs/editor/common/model/tokenStore.js

@@ -1,384 +0,0 @@
-
-
-class ListNode {
-    get children() { return this._children; }
-    get length() { return this._length; }
-    constructor(height) {
-        this.height = height;
-        this._children = [];
-        this._length = 0;
-    }
-    static create(node1, node2) {
-        const list = ( new ListNode(node1.height + 1));
-        list.appendChild(node1);
-        list.appendChild(node2);
-        return list;
-    }
-    canAppendChild() {
-        return this._children.length < 3;
-    }
-    appendChild(node) {
-        if (!this.canAppendChild()) {
-            throw ( new Error('Cannot insert more than 3 children in a ListNode'));
-        }
-        this._children.push(node);
-        this._length += node.length;
-        this._updateParentLength(node.length);
-        node.parent = this;
-    }
-    _updateParentLength(delta) {
-        let updateParent = this.parent;
-        while (updateParent) {
-            updateParent._length += delta;
-            updateParent = updateParent.parent;
-        }
-    }
-    unappendChild() {
-        const child = this._children.pop();
-        this._length -= child.length;
-        this._updateParentLength(-child.length);
-        return child;
-    }
-    prependChild(node) {
-        if (this._children.length >= 3) {
-            throw ( new Error('Cannot prepend more than 3 children in a ListNode'));
-        }
-        this._children.unshift(node);
-        this._length += node.length;
-        this._updateParentLength(node.length);
-        node.parent = this;
-    }
-    unprependChild() {
-        const child = this._children.shift();
-        this._length -= child.length;
-        this._updateParentLength(-child.length);
-        return child;
-    }
-    lastChild() {
-        return this._children[this._children.length - 1];
-    }
-    dispose() {
-        this._children.splice(0, this._children.length);
-    }
-}
-function isLeaf(node) {
-    return node.token !== undefined;
-}
-function append(node, nodeToAppend) {
-    let curNode = node;
-    const parents = [];
-    let nodeToAppendOfCorrectHeight;
-    while (true) {
-        if (nodeToAppend.height === curNode.height) {
-            nodeToAppendOfCorrectHeight = nodeToAppend;
-            break;
-        }
-        if (isLeaf(curNode)) {
-            throw ( new Error('unexpected'));
-        }
-        parents.push(curNode);
-        curNode = curNode.lastChild();
-    }
-    for (let i = parents.length - 1; i >= 0; i--) {
-        const parent = parents[i];
-        if (nodeToAppendOfCorrectHeight) {
-            if (parent.children.length >= 3) {
-                const newList = ListNode.create(parent.unappendChild(), nodeToAppendOfCorrectHeight);
-                nodeToAppendOfCorrectHeight = newList;
-            }
-            else {
-                parent.appendChild(nodeToAppendOfCorrectHeight);
-                nodeToAppendOfCorrectHeight = undefined;
-            }
-        }
-    }
-    if (nodeToAppendOfCorrectHeight) {
-        const newList = ( new ListNode(nodeToAppendOfCorrectHeight.height + 1));
-        newList.appendChild(node);
-        newList.appendChild(nodeToAppendOfCorrectHeight);
-        return newList;
-    }
-    else {
-        return node;
-    }
-}
-function prepend(list, nodeToAppend) {
-    let curNode = list;
-    const parents = [];
-    while (nodeToAppend.height !== curNode.height) {
-        if (isLeaf(curNode)) {
-            throw ( new Error('unexpected'));
-        }
-        parents.push(curNode);
-        curNode = curNode.children[0];
-    }
-    let nodeToPrependOfCorrectHeight = nodeToAppend;
-    for (let i = parents.length - 1; i >= 0; i--) {
-        const parent = parents[i];
-        if (nodeToPrependOfCorrectHeight) {
-            if (parent.children.length >= 3) {
-                nodeToPrependOfCorrectHeight = ListNode.create(nodeToPrependOfCorrectHeight, parent.unprependChild());
-            }
-            else {
-                parent.prependChild(nodeToPrependOfCorrectHeight);
-                nodeToPrependOfCorrectHeight = undefined;
-            }
-        }
-    }
-    if (nodeToPrependOfCorrectHeight) {
-        return ListNode.create(nodeToPrependOfCorrectHeight, list);
-    }
-    else {
-        return list;
-    }
-}
-function concat(node1, node2) {
-    if (node1.height === node2.height) {
-        return ListNode.create(node1, node2);
-    }
-    else if (node1.height > node2.height) {
-        return append(node1, node2);
-    }
-    else {
-        return prepend(node2, node1);
-    }
-}
-class TokenStore {
-    get root() {
-        return this._root;
-    }
-    constructor(_textModel) {
-        this._textModel = _textModel;
-        this._root = this.createEmptyRoot();
-    }
-    createEmptyRoot() {
-        return {
-            length: this._textModel.getValueLength(),
-            token: 0,
-            height: 0
-        };
-    }
-    buildStore(tokens) {
-        this._root = this.createFromUpdates(tokens, true);
-    }
-    createFromUpdates(tokens, needsRefresh) {
-        if (tokens.length === 0) {
-            return this.createEmptyRoot();
-        }
-        let newRoot = {
-            length: tokens[0].length,
-            token: tokens[0].token,
-            height: 0,
-            needsRefresh
-        };
-        for (let j = 1; j < tokens.length; j++) {
-            newRoot = append(newRoot, { length: tokens[j].length, token: tokens[j].token, height: 0, needsRefresh });
-        }
-        return newRoot;
-    }
-    update(length, tokens, needsRefresh) {
-        if (tokens.length === 0) {
-            return;
-        }
-        this.replace(length, tokens[0].startOffsetInclusive, tokens, needsRefresh);
-    }
-    delete(length, startOffset) {
-        this.replace(length, startOffset, [], true);
-    }
-    replace(length, updateOffsetStart, tokens, needsRefresh) {
-        const firstUnchangedOffsetAfterUpdate = updateOffsetStart + length;
-        const precedingNodes = [];
-        const postcedingNodes = [];
-        const stack = [{ node: this._root, offset: 0 }];
-        while (stack.length > 0) {
-            const node = stack.pop();
-            const currentOffset = node.offset;
-            if (currentOffset < updateOffsetStart && currentOffset + node.node.length <= updateOffsetStart) {
-                node.node.parent = undefined;
-                precedingNodes.push(node.node);
-                continue;
-            }
-            else if (isLeaf(node.node) && (currentOffset < updateOffsetStart)) {
-                precedingNodes.push({ length: updateOffsetStart - currentOffset, token: node.node.token, height: 0, needsRefresh: needsRefresh || node.node.needsRefresh });
-            }
-            if ((updateOffsetStart <= currentOffset) && (currentOffset + node.node.length <= firstUnchangedOffsetAfterUpdate)) {
-                continue;
-            }
-            if (currentOffset >= firstUnchangedOffsetAfterUpdate) {
-                node.node.parent = undefined;
-                postcedingNodes.push(node.node);
-                continue;
-            }
-            else if (isLeaf(node.node) && (currentOffset + node.node.length >= firstUnchangedOffsetAfterUpdate)) {
-                postcedingNodes.push({ length: currentOffset + node.node.length - firstUnchangedOffsetAfterUpdate, token: node.node.token, height: 0, needsRefresh: needsRefresh || node.node.needsRefresh });
-                continue;
-            }
-            if (!isLeaf(node.node)) {
-                let childOffset = currentOffset + node.node.length;
-                for (let i = node.node.children.length - 1; i >= 0; i--) {
-                    childOffset -= node.node.children[i].length;
-                    stack.push({ node: node.node.children[i], offset: childOffset });
-                }
-            }
-        }
-        let allNodes;
-        if (tokens.length > 0) {
-            allNodes = precedingNodes.concat(this.createFromUpdates(tokens, needsRefresh), postcedingNodes);
-        }
-        else {
-            allNodes = precedingNodes.concat(postcedingNodes);
-        }
-        let newRoot = allNodes[0];
-        for (let i = 1; i < allNodes.length; i++) {
-            newRoot = concat(newRoot, allNodes[i]);
-        }
-        this._root = newRoot ?? this.createEmptyRoot();
-    }
-    traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, visitor) {
-        const stack = [{ node: this._root, offset: 0 }];
-        while (stack.length > 0) {
-            const { node, offset } = stack.pop();
-            const nodeEnd = offset + node.length;
-            if (nodeEnd <= startOffsetInclusive || offset >= endOffsetExclusive) {
-                continue;
-            }
-            if (visitor(node, offset)) {
-                return;
-            }
-            if (!isLeaf(node)) {
-                let childOffset = offset + node.length;
-                for (let i = node.children.length - 1; i >= 0; i--) {
-                    childOffset -= node.children[i].length;
-                    stack.push({ node: node.children[i], offset: childOffset });
-                }
-            }
-        }
-    }
-    getTokenAt(offset) {
-        let result;
-        this.traverseInOrderInRange(offset, this._root.length, (node, offset) => {
-            if (isLeaf(node)) {
-                result = { token: node.token, startOffsetInclusive: offset, length: node.length };
-                return true;
-            }
-            return false;
-        });
-        return result;
-    }
-    getTokensInRange(startOffsetInclusive, endOffsetExclusive) {
-        const result = [];
-        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node, offset) => {
-            if (isLeaf(node)) {
-                let clippedLength = node.length;
-                let clippedOffset = offset;
-                if (offset < startOffsetInclusive) {
-                    clippedLength -= (startOffsetInclusive - offset);
-                    clippedOffset = startOffsetInclusive;
-                }
-                else if (offset + node.length > endOffsetExclusive) {
-                    clippedLength -= (offset + node.length - endOffsetExclusive);
-                }
-                result.push({ token: node.token, startOffsetInclusive: clippedOffset, length: clippedLength });
-            }
-            return false;
-        });
-        return result;
-    }
-    markForRefresh(startOffsetInclusive, endOffsetExclusive) {
-        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
-            if (isLeaf(node)) {
-                node.needsRefresh = true;
-            }
-            return false;
-        });
-    }
-    rangeNeedsRefresh(startOffsetInclusive, endOffsetExclusive) {
-        let needsRefresh = false;
-        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
-            if (isLeaf(node) && node.needsRefresh) {
-                needsRefresh = true;
-            }
-            return false;
-        });
-        return needsRefresh;
-    }
-    getNeedsRefresh() {
-        const result = [];
-        this.traverseInOrderInRange(0, this._textModel.getValueLength(), (node, offset) => {
-            if (isLeaf(node) && node.needsRefresh) {
-                if ((result.length > 0) && (result[result.length - 1].endOffset === offset)) {
-                    result[result.length - 1].endOffset += node.length;
-                }
-                else {
-                    result.push({ startOffset: offset, endOffset: offset + node.length });
-                }
-            }
-            return false;
-        });
-        return result;
-    }
-    deepCopy() {
-        const newStore = ( new TokenStore(this._textModel));
-        newStore._root = this._copyNodeIterative(this._root);
-        return newStore;
-    }
-    _copyNodeIterative(root) {
-        const newRoot = isLeaf(root)
-            ? { length: root.length, token: root.token, needsRefresh: root.needsRefresh, height: root.height }
-            : ( new ListNode(root.height));
-        const stack = [[root, newRoot]];
-        while (stack.length > 0) {
-            const [oldNode, clonedNode] = stack.pop();
-            if (!isLeaf(oldNode)) {
-                for (const child of oldNode.children) {
-                    const childCopy = isLeaf(child)
-                        ? { length: child.length, token: child.token, needsRefresh: child.needsRefresh, height: child.height }
-                        : ( new ListNode(child.height));
-                    clonedNode.appendChild(childCopy);
-                    stack.push([child, childCopy]);
-                }
-            }
-        }
-        return newRoot;
-    }
-    printTree(root = this._root) {
-        const result = [];
-        const stack = [[root, 0]];
-        while (stack.length > 0) {
-            const [node, depth] = stack.pop();
-            const indent = '  '.repeat(depth);
-            if (isLeaf(node)) {
-                result.push(`${indent}Leaf(length: ${node.length}, token: ${node.token}, refresh: ${node.needsRefresh})\n`);
-            }
-            else {
-                result.push(`${indent}List(length: ${node.length})\n`);
-                for (let i = node.children.length - 1; i >= 0; i--) {
-                    stack.push([node.children[i], depth + 1]);
-                }
-            }
-        }
-        return result.join('');
-    }
-    dispose() {
-        const stack = [[this._root, false]];
-        while (stack.length > 0) {
-            const [node, visited] = stack.pop();
-            if (isLeaf(node)) {
-                node.parent = undefined;
-            }
-            else if (!visited) {
-                stack.push([node, true]);
-                for (let i = node.children.length - 1; i >= 0; i--) {
-                    stack.push([node.children[i], false]);
-                }
-            }
-            else {
-                node.dispose();
-                node.parent = undefined;
-            }
-        }
-        this._root = undefined;
-    }
-}
-
-export { TokenStore };

package/vscode/src/vs/editor/common/model/treeSitterTokenStoreService.d.ts

@@ -1,44 +0,0 @@
-import { Range } from "../core/range.js";
-import { ITextModel } from "../model.js";
-import { TokenUpdate } from "./tokenStore.js";
-import { IDisposable } from "../../../base/common/lifecycle.js";
-export interface ITreeSitterTokenizationStoreService {
-    readonly _serviceBrand: undefined;
-    setTokens(model: ITextModel, tokens: TokenUpdate[]): void;
-    getTokens(model: ITextModel, line: number): Uint32Array | undefined;
-    updateTokens(model: ITextModel, version: number, updates: {
-        oldRangeLength: number;
-        newTokens: TokenUpdate[];
-    }[]): void;
-    markForRefresh(model: ITextModel, range: Range): void;
-    getNeedsRefresh(model: ITextModel): {
-        range: Range;
-        startOffset: number;
-        endOffset: number;
-    }[];
-    hasTokens(model: ITextModel, accurateForRange?: Range): boolean;
-}
-export declare const ITreeSitterTokenizationStoreService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITreeSitterTokenizationStoreService>;
-export interface TokenInformation {
-    tokens: Uint32Array;
-    needsRefresh?: boolean;
-}
-export declare class TreeSitterTokenizationStoreService implements ITreeSitterTokenizationStoreService, IDisposable {
-    readonly _serviceBrand: undefined;
-    private readonly tokens;
-    constructor();
-    setTokens(model: ITextModel, tokens: TokenUpdate[]): void;
-    hasTokens(model: ITextModel, accurateForRange?: Range): boolean;
-    getTokens(model: ITextModel, line: number): Uint32Array | undefined;
-    updateTokens(model: ITextModel, version: number, updates: {
-        oldRangeLength: number;
-        newTokens: TokenUpdate[];
-    }[]): void;
-    markForRefresh(model: ITextModel, range: Range): void;
-    getNeedsRefresh(model: ITextModel): {
-        range: Range;
-        startOffset: number;
-        endOffset: number;
-    }[];
-    dispose(): void;
-}