monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/textModelBracketPairs.js

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class BracketInfo {
+    constructor(range, 
+    /** 0-based level */
+    nestingLevel, nestingLevelOfEqualBracketType, isInvalid) {
+        this.range = range;
+        this.nestingLevel = nestingLevel;
+        this.nestingLevelOfEqualBracketType = nestingLevelOfEqualBracketType;
+        this.isInvalid = isInvalid;
+    }
+}
+class BracketPairInfo {
+    constructor(range, openingBracketRange, closingBracketRange, 
+    /** 0-based */
+    nestingLevel, nestingLevelOfEqualBracketType, bracketPairNode) {
+        this.range = range;
+        this.openingBracketRange = openingBracketRange;
+        this.closingBracketRange = closingBracketRange;
+        this.nestingLevel = nestingLevel;
+        this.nestingLevelOfEqualBracketType = nestingLevelOfEqualBracketType;
+        this.bracketPairNode = bracketPairNode;
+    }
+    get openingBracketInfo() {
+        return this.bracketPairNode.openingBracket.bracketInfo;
+    }
+}
+class BracketPairWithMinIndentationInfo extends BracketPairInfo {
+    constructor(range, openingBracketRange, closingBracketRange, 
+    /**
+     * 0-based
+    */
+    nestingLevel, nestingLevelOfEqualBracketType, bracketPairNode, 
+    /**
+     * -1 if not requested, otherwise the size of the minimum indentation in the bracket pair in terms of visible columns.
+    */
+    minVisibleColumnIndentation) {
+        super(range, openingBracketRange, closingBracketRange, nestingLevel, nestingLevelOfEqualBracketType, bracketPairNode);
+        this.minVisibleColumnIndentation = minVisibleColumnIndentation;
+    }
+}
+
+export { BracketInfo, BracketPairInfo, BracketPairWithMinIndentationInfo };

package/dist/workers/editor/common/textModelDefaults.js

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const EDITOR_MODEL_DEFAULTS = {
+    tabSize: 4,
+    indentSize: 4,
+    insertSpaces: true,
+    detectIndentation: true,
+    trimAutoWhitespace: true,
+    largeFileOptimizations: true,
+    bracketPairColorizationOptions: {
+        enabled: true,
+        independentColorPoolPerBracketType: false,
+    },
+};
+
+export { EDITOR_MODEL_DEFAULTS };

package/dist/workers/editor/common/textModelEditSource.js

@@ -0,0 +1,166 @@
+import { prefixedUuid } from '../../base/common/uuid.js';
+import { TextLength } from './core/text/textLength.js';
+
+const privateSymbol = Symbol('TextModelEditSource');
+class TextModelEditSource {
+    constructor(metadata, _privateCtorGuard) {
+        this.metadata = metadata;
+    }
+    toString() {
+        return `${this.metadata.source}`;
+    }
+    getType() {
+        const metadata = this.metadata;
+        switch (metadata.source) {
+            case 'cursor':
+                return metadata.kind;
+            case 'inlineCompletionAccept':
+                return metadata.source + (metadata.$nes ? ':nes' : '');
+            case 'unknown':
+                return metadata.name || 'unknown';
+            default:
+                return metadata.source;
+        }
+    }
+    /**
+     * Converts the metadata to a key string.
+     * Only includes properties/values that have `level` many `$` prefixes or less.
+    */
+    toKey(level, filter = {}) {
+        const metadata = this.metadata;
+        const keys = Object.entries(metadata).filter(([key, value]) => {
+            const filterVal = filter[key];
+            if (filterVal !== undefined) {
+                return filterVal;
+            }
+            const prefixCount = (key.match(/\$/g) || []).length;
+            return prefixCount <= level && value !== undefined && value !== null && value !== '';
+        }).map(([key, value]) => `${key}:${value}`);
+        return keys.join('-');
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createEditSource(metadata) {
+    // eslint-disable-next-line local/code-no-any-casts, @typescript-eslint/no-explicit-any
+    return new TextModelEditSource(metadata, privateSymbol);
+}
+const EditSources = {
+    unknown(data) {
+        return createEditSource({
+            source: 'unknown',
+            name: data.name,
+        });
+    },
+    rename: () => createEditSource({ source: 'rename' }),
+    chatApplyEdits(data) {
+        return createEditSource({
+            source: 'Chat.applyEdits',
+            $modelId: avoidPathRedaction(data.modelId),
+            $extensionId: data.extensionId?.extensionId,
+            $extensionVersion: data.extensionId?.version,
+            $$languageId: data.languageId,
+            $$sessionId: data.sessionId,
+            $$requestId: data.requestId,
+            $$mode: data.mode,
+            $$codeBlockSuggestionId: data.codeBlockSuggestionId,
+        });
+    },
+    chatUndoEdits: () => createEditSource({ source: 'Chat.undoEdits' }),
+    chatReset: () => createEditSource({ source: 'Chat.reset' }),
+    inlineCompletionAccept(data) {
+        return createEditSource({
+            source: 'inlineCompletionAccept',
+            $nes: data.nes,
+            ...toProperties(data.providerId),
+            $$requestUuid: data.requestUuid,
+            $$languageId: data.languageId,
+        });
+    },
+    inlineCompletionPartialAccept(data) {
+        return createEditSource({
+            source: 'inlineCompletionPartialAccept',
+            type: data.type,
+            $nes: data.nes,
+            ...toProperties(data.providerId),
+            $$requestUuid: data.requestUuid,
+            $$languageId: data.languageId,
+        });
+    },
+    inlineChatApplyEdit(data) {
+        return createEditSource({
+            source: 'inlineChat.applyEdits',
+            $modelId: avoidPathRedaction(data.modelId),
+            $extensionId: data.extensionId?.extensionId,
+            $extensionVersion: data.extensionId?.version,
+            $$sessionId: data.sessionId,
+            $$requestId: data.requestId,
+            $$languageId: data.languageId,
+        });
+    },
+    reloadFromDisk: () => createEditSource({ source: 'reloadFromDisk' }),
+    cursor(data) {
+        return createEditSource({
+            source: 'cursor',
+            kind: data.kind,
+            detailedSource: data.detailedSource,
+        });
+    },
+    setValue: () => createEditSource({ source: 'setValue' }),
+    eolChange: () => createEditSource({ source: 'eolChange' }),
+    applyEdits: () => createEditSource({ source: 'applyEdits' }),
+    snippet: () => createEditSource({ source: 'snippet' }),
+    suggest: (data) => createEditSource({ source: 'suggest', ...toProperties(data.providerId) }),
+    codeAction: (data) => createEditSource({ source: 'codeAction', $kind: data.kind, ...toProperties(data.providerId) })
+};
+function toProperties(version) {
+    if (!version) {
+        return {};
+    }
+    return {
+        $extensionId: version.extensionId,
+        $extensionVersion: version.extensionVersion,
+        $providerId: version.providerId,
+    };
+}
+function avoidPathRedaction(str) {
+    if (str === undefined) {
+        return undefined;
+    }
+    // To avoid false-positive file path redaction.
+    return str.replaceAll('/', '|');
+}
+class EditDeltaInfo {
+    static fromText(text) {
+        const linesAdded = TextLength.ofText(text).lineCount;
+        const charsAdded = text.length;
+        return new EditDeltaInfo(linesAdded, 0, charsAdded, 0);
+    }
+    static tryCreate(linesAdded, linesRemoved, charsAdded, charsRemoved) {
+        if (linesAdded === undefined || linesRemoved === undefined || charsAdded === undefined || charsRemoved === undefined) {
+            return undefined;
+        }
+        return new EditDeltaInfo(linesAdded, linesRemoved, charsAdded, charsRemoved);
+    }
+    constructor(linesAdded, linesRemoved, charsAdded, charsRemoved) {
+        this.linesAdded = linesAdded;
+        this.linesRemoved = linesRemoved;
+        this.charsAdded = charsAdded;
+        this.charsRemoved = charsRemoved;
+    }
+}
+var EditSuggestionId;
+(function (EditSuggestionId) {
+    /**
+     * Use AiEditTelemetryServiceImpl to create a new id!
+    */
+    function newId(genPrefixedUuid) {
+        const id = genPrefixedUuid ? genPrefixedUuid('sgt') : prefixedUuid('sgt');
+        return toEditIdentity(id);
+    }
+    EditSuggestionId.newId = newId;
+})(EditSuggestionId || (EditSuggestionId = {}));
+function toEditIdentity(id) {
+    return id;
+}
+
+export { EditDeltaInfo, EditSources, EditSuggestionId, TextModelEditSource };

package/dist/workers/editor/common/textModelEvents.js

@@ -0,0 +1,216 @@
+/**
+ * An event describing that a model has been reset to a new value.
+ * @internal
+ */
+class ModelRawFlush {
+    constructor() {
+        this.changeType = 1 /* RawContentChangedType.Flush */;
+    }
+}
+/**
+ * Represents text injected on a line
+ * @internal
+ */
+class LineInjectedText {
+    static applyInjectedText(lineText, injectedTexts) {
+        if (!injectedTexts || injectedTexts.length === 0) {
+            return lineText;
+        }
+        let result = '';
+        let lastOriginalOffset = 0;
+        for (const injectedText of injectedTexts) {
+            result += lineText.substring(lastOriginalOffset, injectedText.column - 1);
+            lastOriginalOffset = injectedText.column - 1;
+            result += injectedText.options.content;
+        }
+        result += lineText.substring(lastOriginalOffset);
+        return result;
+    }
+    static fromDecorations(decorations) {
+        const result = [];
+        for (const decoration of decorations) {
+            if (decoration.options.before && decoration.options.before.content.length > 0) {
+                result.push(new LineInjectedText(decoration.ownerId, decoration.range.startLineNumber, decoration.range.startColumn, decoration.options.before, 0));
+            }
+            if (decoration.options.after && decoration.options.after.content.length > 0) {
+                result.push(new LineInjectedText(decoration.ownerId, decoration.range.endLineNumber, decoration.range.endColumn, decoration.options.after, 1));
+            }
+        }
+        result.sort((a, b) => {
+            if (a.lineNumber === b.lineNumber) {
+                if (a.column === b.column) {
+                    return a.order - b.order;
+                }
+                return a.column - b.column;
+            }
+            return a.lineNumber - b.lineNumber;
+        });
+        return result;
+    }
+    constructor(ownerId, lineNumber, column, options, order) {
+        this.ownerId = ownerId;
+        this.lineNumber = lineNumber;
+        this.column = column;
+        this.options = options;
+        this.order = order;
+    }
+}
+/**
+ * An event describing that a line has changed in a model.
+ * @internal
+ */
+class ModelRawLineChanged {
+    constructor(lineNumber, detail, injectedText) {
+        this.changeType = 2 /* RawContentChangedType.LineChanged */;
+        this.lineNumber = lineNumber;
+        this.detail = detail;
+        this.injectedText = injectedText;
+    }
+}
+/**
+ * An event describing that a line height has changed in the model.
+ * @internal
+ */
+class ModelLineHeightChanged {
+    constructor(ownerId, decorationId, lineNumber, lineHeight) {
+        this.ownerId = ownerId;
+        this.decorationId = decorationId;
+        this.lineNumber = lineNumber;
+        this.lineHeight = lineHeight;
+    }
+}
+/**
+ * An event describing that a line height has changed in the model.
+ * @internal
+ */
+class ModelFontChanged {
+    constructor(ownerId, lineNumber) {
+        this.ownerId = ownerId;
+        this.lineNumber = lineNumber;
+    }
+}
+/**
+ * An event describing that line(s) have been deleted in a model.
+ * @internal
+ */
+class ModelRawLinesDeleted {
+    constructor(fromLineNumber, toLineNumber) {
+        this.changeType = 3 /* RawContentChangedType.LinesDeleted */;
+        this.fromLineNumber = fromLineNumber;
+        this.toLineNumber = toLineNumber;
+    }
+}
+/**
+ * An event describing that line(s) have been inserted in a model.
+ * @internal
+ */
+class ModelRawLinesInserted {
+    constructor(fromLineNumber, toLineNumber, detail, injectedTexts) {
+        this.changeType = 4 /* RawContentChangedType.LinesInserted */;
+        this.injectedTexts = injectedTexts;
+        this.fromLineNumber = fromLineNumber;
+        this.toLineNumber = toLineNumber;
+        this.detail = detail;
+    }
+}
+/**
+ * An event describing that a model has had its EOL changed.
+ * @internal
+ */
+class ModelRawEOLChanged {
+    constructor() {
+        this.changeType = 5 /* RawContentChangedType.EOLChanged */;
+    }
+}
+/**
+ * An event describing a change in the text of a model.
+ * @internal
+ */
+class ModelRawContentChangedEvent {
+    constructor(changes, versionId, isUndoing, isRedoing) {
+        this.changes = changes;
+        this.versionId = versionId;
+        this.isUndoing = isUndoing;
+        this.isRedoing = isRedoing;
+        this.resultingSelection = null;
+    }
+    containsEvent(type) {
+        for (let i = 0, len = this.changes.length; i < len; i++) {
+            const change = this.changes[i];
+            if (change.changeType === type) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static merge(a, b) {
+        const changes = [].concat(a.changes).concat(b.changes);
+        const versionId = b.versionId;
+        const isUndoing = (a.isUndoing || b.isUndoing);
+        const isRedoing = (a.isRedoing || b.isRedoing);
+        return new ModelRawContentChangedEvent(changes, versionId, isUndoing, isRedoing);
+    }
+}
+/**
+ * An event describing a change in injected text.
+ * @internal
+ */
+class ModelInjectedTextChangedEvent {
+    constructor(changes) {
+        this.changes = changes;
+    }
+}
+/**
+ * An event describing a change of a line height.
+ * @internal
+ */
+class ModelLineHeightChangedEvent {
+    constructor(changes) {
+        this.changes = changes;
+    }
+}
+/**
+ * An event describing a change in fonts.
+ * @internal
+ */
+class ModelFontChangedEvent {
+    constructor(changes) {
+        this.changes = changes;
+    }
+}
+/**
+ * @internal
+ */
+class InternalModelContentChangeEvent {
+    constructor(rawContentChangedEvent, contentChangedEvent) {
+        this.rawContentChangedEvent = rawContentChangedEvent;
+        this.contentChangedEvent = contentChangedEvent;
+    }
+    merge(other) {
+        const rawContentChangedEvent = ModelRawContentChangedEvent.merge(this.rawContentChangedEvent, other.rawContentChangedEvent);
+        const contentChangedEvent = InternalModelContentChangeEvent._mergeChangeEvents(this.contentChangedEvent, other.contentChangedEvent);
+        return new InternalModelContentChangeEvent(rawContentChangedEvent, contentChangedEvent);
+    }
+    static _mergeChangeEvents(a, b) {
+        const changes = [].concat(a.changes).concat(b.changes);
+        const eol = b.eol;
+        const versionId = b.versionId;
+        const isUndoing = (a.isUndoing || b.isUndoing);
+        const isRedoing = (a.isRedoing || b.isRedoing);
+        const isFlush = (a.isFlush || b.isFlush);
+        const isEolChange = a.isEolChange && b.isEolChange; // both must be true to not confuse listeners who skip such edits
+        return {
+            changes: changes,
+            eol: eol,
+            isEolChange: isEolChange,
+            versionId: versionId,
+            isUndoing: isUndoing,
+            isRedoing: isRedoing,
+            isFlush: isFlush,
+            detailedReasons: a.detailedReasons.concat(b.detailedReasons),
+            detailedReasonsChangeLengths: a.detailedReasonsChangeLengths.concat(b.detailedReasonsChangeLengths),
+        };
+    }
+}
+
+export { InternalModelContentChangeEvent, LineInjectedText, ModelFontChanged, ModelFontChangedEvent, ModelInjectedTextChangedEvent, ModelLineHeightChanged, ModelLineHeightChangedEvent, ModelRawContentChangedEvent, ModelRawEOLChanged, ModelRawFlush, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted };

package/dist/workers/editor/common/textModelGuides.js

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var HorizontalGuidesState;
+(function (HorizontalGuidesState) {
+    HorizontalGuidesState[HorizontalGuidesState["Disabled"] = 0] = "Disabled";
+    HorizontalGuidesState[HorizontalGuidesState["EnabledForActive"] = 1] = "EnabledForActive";
+    HorizontalGuidesState[HorizontalGuidesState["Enabled"] = 2] = "Enabled";
+})(HorizontalGuidesState || (HorizontalGuidesState = {}));
+class IndentGuide {
+    constructor(visibleColumn, column, className, 
+    /**
+     * If set, this indent guide is a horizontal guide (no vertical part).
+     * It starts at visibleColumn and continues until endColumn.
+    */
+    horizontalLine, 
+    /**
+     * If set (!= -1), only show this guide for wrapped lines that don't contain this model column, but are after it.
+    */
+    forWrappedLinesAfterColumn, forWrappedLinesBeforeOrAtColumn) {
+        this.visibleColumn = visibleColumn;
+        this.column = column;
+        this.className = className;
+        this.horizontalLine = horizontalLine;
+        this.forWrappedLinesAfterColumn = forWrappedLinesAfterColumn;
+        this.forWrappedLinesBeforeOrAtColumn = forWrappedLinesBeforeOrAtColumn;
+        if ((visibleColumn !== -1) === (column !== -1)) {
+            throw new Error();
+        }
+    }
+}
+class IndentGuideHorizontalLine {
+    constructor(top, endColumn) {
+        this.top = top;
+        this.endColumn = endColumn;
+    }
+}
+
+export { HorizontalGuidesState, IndentGuide, IndentGuideHorizontalLine };

package/dist/workers/editor/common/textModelPart.js

@@ -0,0 +1,23 @@
+import { Disposable } from '../../../base/common/lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class TextModelPart extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._isDisposed = false;
+    }
+    dispose() {
+        super.dispose();
+        this._isDisposed = true;
+    }
+    assertNotDisposed() {
+        if (this._isDisposed) {
+            throw new Error('TextModelPart is disposed!');
+        }
+    }
+}
+
+export { TextModelPart };