monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,193 @@
+import { getLeadingWhitespace } from '../../../../base/common/strings.js';
+import { createScopedLineTokens } from '../supports.js';
+import { LineTokens } from '../../tokens/lineTokens.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * This class is a wrapper class around {@link IndentRulesSupport}.
+ * It processes the lines by removing the language configuration brackets from the regex, string and comment tokens.
+ * It then calls into the {@link IndentRulesSupport} to validate the indentation conditions.
+ */
+class ProcessedIndentRulesSupport {
+    constructor(model, indentRulesSupport, languageConfigurationService) {
+        this._indentRulesSupport = indentRulesSupport;
+        this._indentationLineProcessor = new IndentationLineProcessor(model, languageConfigurationService);
+    }
+    /**
+     * Apply the new indentation and return whether the indentation level should be increased after the given line number
+     */
+    shouldIncrease(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldIncrease(processedLine);
+    }
+    /**
+     * Apply the new indentation and return whether the indentation level should be decreased after the given line number
+     */
+    shouldDecrease(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldDecrease(processedLine);
+    }
+    /**
+     * Apply the new indentation and return whether the indentation level should remain unchanged at the given line number
+     */
+    shouldIgnore(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldIgnore(processedLine);
+    }
+    /**
+     * Apply the new indentation and return whether the indentation level should increase on the line after the given line number
+     */
+    shouldIndentNextLine(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldIndentNextLine(processedLine);
+    }
+}
+/**
+ * This class fetches the processed text around a range which can be used for indentation evaluation.
+ * It returns:
+ * - The processed text before the given range and on the same start line
+ * - The processed text after the given range and on the same end line
+ * - The processed text on the previous line
+ */
+class IndentationContextProcessor {
+    constructor(model, languageConfigurationService) {
+        this.model = model;
+        this.indentationLineProcessor = new IndentationLineProcessor(model, languageConfigurationService);
+    }
+    /**
+     * Returns the processed text, stripped from the language configuration brackets within the string, comment and regex tokens, around the given range
+     */
+    getProcessedTokenContextAroundRange(range) {
+        const beforeRangeProcessedTokens = this._getProcessedTokensBeforeRange(range);
+        const afterRangeProcessedTokens = this._getProcessedTokensAfterRange(range);
+        const previousLineProcessedTokens = this._getProcessedPreviousLineTokens(range);
+        return { beforeRangeProcessedTokens, afterRangeProcessedTokens, previousLineProcessedTokens };
+    }
+    _getProcessedTokensBeforeRange(range) {
+        this.model.tokenization.forceTokenization(range.startLineNumber);
+        const lineTokens = this.model.tokenization.getLineTokens(range.startLineNumber);
+        const scopedLineTokens = createScopedLineTokens(lineTokens, range.startColumn - 1);
+        let slicedTokens;
+        if (isLanguageDifferentFromLineStart(this.model, range.getStartPosition())) {
+            const columnIndexWithinScope = (range.startColumn - 1) - scopedLineTokens.firstCharOffset;
+            const firstCharacterOffset = scopedLineTokens.firstCharOffset;
+            const lastCharacterOffset = firstCharacterOffset + columnIndexWithinScope;
+            slicedTokens = lineTokens.sliceAndInflate(firstCharacterOffset, lastCharacterOffset, 0);
+        }
+        else {
+            const columnWithinLine = range.startColumn - 1;
+            slicedTokens = lineTokens.sliceAndInflate(0, columnWithinLine, 0);
+        }
+        const processedTokens = this.indentationLineProcessor.getProcessedTokens(slicedTokens);
+        return processedTokens;
+    }
+    _getProcessedTokensAfterRange(range) {
+        const position = range.isEmpty() ? range.getStartPosition() : range.getEndPosition();
+        this.model.tokenization.forceTokenization(position.lineNumber);
+        const lineTokens = this.model.tokenization.getLineTokens(position.lineNumber);
+        const scopedLineTokens = createScopedLineTokens(lineTokens, position.column - 1);
+        const columnIndexWithinScope = position.column - 1 - scopedLineTokens.firstCharOffset;
+        const firstCharacterOffset = scopedLineTokens.firstCharOffset + columnIndexWithinScope;
+        const lastCharacterOffset = scopedLineTokens.firstCharOffset + scopedLineTokens.getLineLength();
+        const slicedTokens = lineTokens.sliceAndInflate(firstCharacterOffset, lastCharacterOffset, 0);
+        const processedTokens = this.indentationLineProcessor.getProcessedTokens(slicedTokens);
+        return processedTokens;
+    }
+    _getProcessedPreviousLineTokens(range) {
+        const getScopedLineTokensAtEndColumnOfLine = (lineNumber) => {
+            this.model.tokenization.forceTokenization(lineNumber);
+            const lineTokens = this.model.tokenization.getLineTokens(lineNumber);
+            const endColumnOfLine = this.model.getLineMaxColumn(lineNumber) - 1;
+            const scopedLineTokensAtEndColumn = createScopedLineTokens(lineTokens, endColumnOfLine);
+            return scopedLineTokensAtEndColumn;
+        };
+        this.model.tokenization.forceTokenization(range.startLineNumber);
+        const lineTokens = this.model.tokenization.getLineTokens(range.startLineNumber);
+        const scopedLineTokens = createScopedLineTokens(lineTokens, range.startColumn - 1);
+        const emptyTokens = LineTokens.createEmpty('', scopedLineTokens.languageIdCodec);
+        const previousLineNumber = range.startLineNumber - 1;
+        const isFirstLine = previousLineNumber === 0;
+        if (isFirstLine) {
+            return emptyTokens;
+        }
+        const canScopeExtendOnPreviousLine = scopedLineTokens.firstCharOffset === 0;
+        if (!canScopeExtendOnPreviousLine) {
+            return emptyTokens;
+        }
+        const scopedLineTokensAtEndColumnOfPreviousLine = getScopedLineTokensAtEndColumnOfLine(previousLineNumber);
+        const doesLanguageContinueOnPreviousLine = scopedLineTokens.languageId === scopedLineTokensAtEndColumnOfPreviousLine.languageId;
+        if (!doesLanguageContinueOnPreviousLine) {
+            return emptyTokens;
+        }
+        const previousSlicedLineTokens = scopedLineTokensAtEndColumnOfPreviousLine.toIViewLineTokens();
+        const processedTokens = this.indentationLineProcessor.getProcessedTokens(previousSlicedLineTokens);
+        return processedTokens;
+    }
+}
+/**
+ * This class performs the actual processing of the indentation lines.
+ * The brackets of the language configuration are removed from the regex, string and comment tokens.
+ */
+class IndentationLineProcessor {
+    constructor(model, languageConfigurationService) {
+        this.model = model;
+        this.languageConfigurationService = languageConfigurationService;
+    }
+    /**
+     * Get the processed line for the given line number and potentially adjust the indentation level.
+     * Remove the language configuration brackets from the regex, string and comment tokens.
+     */
+    getProcessedLine(lineNumber, newIndentation) {
+        const replaceIndentation = (line, newIndentation) => {
+            const currentIndentation = getLeadingWhitespace(line);
+            const adjustedLine = newIndentation + line.substring(currentIndentation.length);
+            return adjustedLine;
+        };
+        this.model.tokenization.forceTokenization?.(lineNumber);
+        const tokens = this.model.tokenization.getLineTokens(lineNumber);
+        let processedLine = this.getProcessedTokens(tokens).getLineContent();
+        if (newIndentation !== undefined) {
+            processedLine = replaceIndentation(processedLine, newIndentation);
+        }
+        return processedLine;
+    }
+    /**
+     * Process the line with the given tokens, remove the language configuration brackets from the regex, string and comment tokens.
+     */
+    getProcessedTokens(tokens) {
+        const shouldRemoveBracketsFromTokenType = (tokenType) => {
+            return tokenType === 2 /* StandardTokenType.String */
+                || tokenType === 3 /* StandardTokenType.RegEx */
+                || tokenType === 1 /* StandardTokenType.Comment */;
+        };
+        const languageId = tokens.getLanguageId(0);
+        const bracketsConfiguration = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew;
+        const bracketsRegExp = bracketsConfiguration.getBracketRegExp({ global: true });
+        const textAndMetadata = [];
+        tokens.forEach((tokenIndex) => {
+            const tokenType = tokens.getStandardTokenType(tokenIndex);
+            let text = tokens.getTokenText(tokenIndex);
+            if (shouldRemoveBracketsFromTokenType(tokenType)) {
+                text = text.replace(bracketsRegExp, '');
+            }
+            const metadata = tokens.getMetadata(tokenIndex);
+            textAndMetadata.push({ text, metadata });
+        });
+        const processedLineTokens = LineTokens.createFromTextAndMetadata(textAndMetadata, tokens.languageIdCodec);
+        return processedLineTokens;
+    }
+}
+function isLanguageDifferentFromLineStart(model, position) {
+    model.tokenization.forceTokenization(position.lineNumber);
+    const lineTokens = model.tokenization.getLineTokens(position.lineNumber);
+    const scopedLineTokens = createScopedLineTokens(lineTokens, position.column - 1);
+    const doesScopeStartAtOffsetZero = scopedLineTokens.firstCharOffset === 0;
+    const isScopedLanguageEqualToFirstLanguageOnLine = lineTokens.getLanguageId(0) === scopedLineTokens.languageId;
+    const languageIsDifferentFromLineStart = !doesScopeStartAtOffsetZero && !isScopedLanguageEqualToFirstLanguageOnLine;
+    return languageIsDifferentFromLineStart;
+}
+
+export { IndentationContextProcessor, ProcessedIndentRulesSupport, isLanguageDifferentFromLineStart };

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

@@ -0,0 +1,26 @@
+import { Range } from '../core/range.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class InlineDecoration {
+    constructor(range, inlineClassName, type) {
+        this.range = range;
+        this.inlineClassName = inlineClassName;
+        this.type = type;
+    }
+}
+class SingleLineInlineDecoration {
+    constructor(startOffset, endOffset, inlineClassName, inlineClassNameAffectsLetterSpacing) {
+        this.startOffset = startOffset;
+        this.endOffset = endOffset;
+        this.inlineClassName = inlineClassName;
+        this.inlineClassNameAffectsLetterSpacing = inlineClassNameAffectsLetterSpacing;
+    }
+    toInlineDecoration(lineNumber) {
+        return new InlineDecoration(new Range(lineNumber, this.startOffset + 1, lineNumber, this.endOffset + 1), this.inlineClassName, this.inlineClassNameAffectsLetterSpacing ? 3 /* InlineDecorationType.RegularAffectingLetterSpacing */ : 0 /* InlineDecorationType.Regular */);
+    }
+}
+
+export { InlineDecoration, SingleLineInlineDecoration };

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

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class BasicInplaceReplace {
+    constructor() {
+        this._defaultValueSet = [
+            ['true', 'false'],
+            ['True', 'False'],
+            ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],
+            ['public', 'protected', 'private'],
+        ];
+    }
+    static { this.INSTANCE = new BasicInplaceReplace(); }
+    navigateValueSet(range1, text1, range2, text2, up) {
+        if (range1 && text1) {
+            const result = this.doNavigateValueSet(text1, up);
+            if (result) {
+                return {
+                    range: range1,
+                    value: result
+                };
+            }
+        }
+        if (range2 && text2) {
+            const result = this.doNavigateValueSet(text2, up);
+            if (result) {
+                return {
+                    range: range2,
+                    value: result
+                };
+            }
+        }
+        return null;
+    }
+    doNavigateValueSet(text, up) {
+        const numberResult = this.numberReplace(text, up);
+        if (numberResult !== null) {
+            return numberResult;
+        }
+        return this.textReplace(text, up);
+    }
+    numberReplace(value, up) {
+        const precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));
+        let n1 = Number(value);
+        const n2 = parseFloat(value);
+        if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {
+            if (n1 === 0 && !up) {
+                return null; // don't do negative
+                //			} else if(n1 === 9 && up) {
+                //				return null; // don't insert 10 into a number
+            }
+            else {
+                n1 = Math.floor(n1 * precision);
+                n1 += up ? precision : -precision;
+                return String(n1 / precision);
+            }
+        }
+        return null;
+    }
+    textReplace(value, up) {
+        return this.valueSetsReplace(this._defaultValueSet, value, up);
+    }
+    valueSetsReplace(valueSets, value, up) {
+        let result = null;
+        for (let i = 0, len = valueSets.length; result === null && i < len; i++) {
+            result = this.valueSetReplace(valueSets[i], value, up);
+        }
+        return result;
+    }
+    valueSetReplace(valueSet, value, up) {
+        let idx = valueSet.indexOf(value);
+        if (idx >= 0) {
+            idx += up ? 1 : -1;
+            if (idx < 0) {
+                idx = valueSet.length - 1;
+            }
+            else {
+                idx %= valueSet.length;
+            }
+            return valueSet[idx];
+        }
+        return null;
+    }
+}
+
+export { BasicInplaceReplace };

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

@@ -0,0 +1,22 @@
+import { Emitter } from '../../base/common/event.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class InputModeImpl {
+    constructor() {
+        this._inputMode = 'insert';
+        this._onDidChangeInputMode = new Emitter();
+        this.onDidChangeInputMode = this._onDidChangeInputMode.event;
+    }
+    getInputMode() {
+        return this._inputMode;
+    }
+}
+/**
+ * Controls the type mode, whether insert or overtype
+ */
+const InputMode = new InputModeImpl();
+
+export { InputMode };