@codingame/monaco-vscode-api 1.76.8 → 1.78.0-next.0

package/dist/configuration2.js

@@ -1,327 +1,8 @@
-import { Y as parseTree, Z as findNodeAtLocation, _ as createScanner } from './polyfill.js';
-function format(documentText, range, options) {
-    let initialIndentLevel;
-    let formatText;
-    let formatTextStart;
-    let rangeStart;
-    let rangeEnd;
-    if (range) {
-        rangeStart = range.offset;
-        rangeEnd = rangeStart + range.length;
-        formatTextStart = rangeStart;
-        while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
-            formatTextStart--;
-        }
-        let endOffset = rangeEnd;
-        while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
-            endOffset++;
-        }
-        formatText = documentText.substring(formatTextStart, endOffset);
-        initialIndentLevel = computeIndentLevel(formatText, options);
-    }
-    else {
-        formatText = documentText;
-        initialIndentLevel = 0;
-        formatTextStart = 0;
-        rangeStart = 0;
-        rangeEnd = documentText.length;
-    }
-    const eol = getEOL(options, documentText);
-    let lineBreak = false;
-    let indentLevel = 0;
-    let indentValue;
-    if (options.insertSpaces) {
-        indentValue = repeat(' ', options.tabSize || 4);
-    }
-    else {
-        indentValue = '\t';
-    }
-    const scanner = createScanner(formatText, false);
-    let hasError = false;
-    function newLineAndIndent() {
-        return eol + repeat(indentValue, initialIndentLevel + indentLevel);
-    }
-    function scanNext() {
-        let token = scanner.scan();
-        lineBreak = false;
-        while (token === 15  || token === 14 ) {
-            lineBreak = lineBreak || (token === 14 );
-            token = scanner.scan();
-        }
-        hasError = token === 16  || scanner.getTokenError() !== 0 ;
-        return token;
-    }
-    const editOperations = [];
-    function addEdit(text, startOffset, endOffset) {
-        if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
-            editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
-        }
-    }
-    let firstToken = scanNext();
-    if (firstToken !== 17 ) {
-        const firstTokenStart = scanner.getTokenOffset() + formatTextStart;
-        const initialIndent = repeat(indentValue, initialIndentLevel);
-        addEdit(initialIndent, formatTextStart, firstTokenStart);
-    }
-    while (firstToken !== 17 ) {
-        let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
-        let secondToken = scanNext();
-        let replaceContent = '';
-        while (!lineBreak && (secondToken === 12  || secondToken === 13 )) {
-            const commentTokenStart = scanner.getTokenOffset() + formatTextStart;
-            addEdit(' ', firstTokenEnd, commentTokenStart);
-            firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
-            replaceContent = secondToken === 12  ? newLineAndIndent() : '';
-            secondToken = scanNext();
-        }
-        if (secondToken === 2 ) {
-            if (firstToken !== 1 ) {
-                indentLevel--;
-                replaceContent = newLineAndIndent();
-            }
-        }
-        else if (secondToken === 4 ) {
-            if (firstToken !== 3 ) {
-                indentLevel--;
-                replaceContent = newLineAndIndent();
-            }
-        }
-        else {
-            switch (firstToken) {
-                case 3 :
-                case 1 :
-                    indentLevel++;
-                    replaceContent = newLineAndIndent();
-                    break;
-                case 5 :
-                case 12 :
-                    replaceContent = newLineAndIndent();
-                    break;
-                case 13 :
-                    if (lineBreak) {
-                        replaceContent = newLineAndIndent();
-                    }
-                    else {
-                        replaceContent = ' ';
-                    }
-                    break;
-                case 6 :
-                    replaceContent = ' ';
-                    break;
-                case 10 :
-                    if (secondToken === 6 ) {
-                        replaceContent = '';
-                        break;
-                    }
-                case 7 :
-                case 8 :
-                case 9 :
-                case 11 :
-                case 2 :
-                case 4 :
-                    if (secondToken === 12  || secondToken === 13 ) {
-                        replaceContent = ' ';
-                    }
-                    else if (secondToken !== 5  && secondToken !== 17 ) {
-                        hasError = true;
-                    }
-                    break;
-                case 16 :
-                    hasError = true;
-                    break;
-            }
-            if (lineBreak && (secondToken === 12  || secondToken === 13 )) {
-                replaceContent = newLineAndIndent();
-            }
-        }
-        const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
-        addEdit(replaceContent, firstTokenEnd, secondTokenStart);
-        firstToken = secondToken;
-    }
-    return editOperations;
-}
-function repeat(s, count) {
-    let result = '';
-    for (let i = 0; i < count; i++) {
-        result += s;
-    }
-    return result;
-}
-function computeIndentLevel(content, options) {
-    let i = 0;
-    let nChars = 0;
-    const tabSize = options.tabSize || 4;
-    while (i < content.length) {
-        const ch = content.charAt(i);
-        if (ch === ' ') {
-            nChars++;
-        }
-        else if (ch === '\t') {
-            nChars += tabSize;
-        }
-        else {
-            break;
-        }
-        i++;
-    }
-    return Math.floor(nChars / tabSize);
-}
-function getEOL(options, text) {
-    for (let i = 0; i < text.length; i++) {
-        const ch = text.charAt(i);
-        if (ch === '\r') {
-            if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
-                return '\r\n';
-            }
-            return '\r';
-        }
-        else if (ch === '\n') {
-            return '\n';
-        }
-    }
-    return (options && options.eol) || '\n';
-}
-function isEOL(text, offset) {
-    return '\r\n'.indexOf(text.charAt(offset)) !== -1;
-}
-function setProperty(text, originalPath, value, formattingOptions, getInsertionIndex) {
-    const path = originalPath.slice();
-    const errors = [];
-    const root = parseTree(text, errors);
-    let parent = undefined;
-    let lastSegment = undefined;
-    while (path.length > 0) {
-        lastSegment = path.pop();
-        parent = findNodeAtLocation(root, path);
-        if (parent === undefined && value !== undefined) {
-            if (typeof lastSegment === 'string') {
-                value = { [lastSegment]: value };
-            }
-            else {
-                value = [value];
-            }
-        }
-        else {
-            break;
-        }
-    }
-    if (!parent) {
-        if (value === undefined) {
-            throw new Error('Can not delete in empty document');
-        }
-        return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, formattingOptions);
-    }
-    else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
-        const existing = findNodeAtLocation(parent, [lastSegment]);
-        if (existing !== undefined) {
-            if (value === undefined) {
-                if (!existing.parent) {
-                    throw new Error('Malformed AST');
-                }
-                const propertyIndex = parent.children.indexOf(existing.parent);
-                let removeBegin;
-                let removeEnd = existing.parent.offset + existing.parent.length;
-                if (propertyIndex > 0) {
-                    const previous = parent.children[propertyIndex - 1];
-                    removeBegin = previous.offset + previous.length;
-                }
-                else {
-                    removeBegin = parent.offset + 1;
-                    if (parent.children.length > 1) {
-                        const next = parent.children[1];
-                        removeEnd = next.offset;
-                    }
-                }
-                return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, formattingOptions);
-            }
-            else {
-                return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, formattingOptions);
-            }
-        }
-        else {
-            if (value === undefined) {
-                return [];
-            }
-            const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
-            const index = getInsertionIndex ? getInsertionIndex(( parent.children.map(p => p.children[0].value))) : parent.children.length;
-            let edit;
-            if (index > 0) {
-                const previous = parent.children[index - 1];
-                edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
-            }
-            else if (parent.children.length === 0) {
-                edit = { offset: parent.offset + 1, length: 0, content: newProperty };
-            }
-            else {
-                edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
-            }
-            return withFormatting(text, edit, formattingOptions);
-        }
-    }
-    else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
-        if (value !== undefined) {
-            const newProperty = `${JSON.stringify(value)}`;
-            let edit;
-            if (parent.children.length === 0 || lastSegment === 0) {
-                edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + ',' };
-            }
-            else {
-                const index = lastSegment === -1 || lastSegment > parent.children.length ? parent.children.length : lastSegment;
-                const previous = parent.children[index - 1];
-                edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
-            }
-            return withFormatting(text, edit, formattingOptions);
-        }
-        else {
-            const removalIndex = lastSegment;
-            const toRemove = parent.children[removalIndex];
-            let edit;
-            if (parent.children.length === 1) {
-                edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
-            }
-            else if (parent.children.length - 1 === removalIndex) {
-                const previous = parent.children[removalIndex - 1];
-                const offset = previous.offset + previous.length;
-                const parentEndOffset = parent.offset + parent.length;
-                edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
-            }
-            else {
-                edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
-            }
-            return withFormatting(text, edit, formattingOptions);
-        }
-    }
-    else {
-        throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
-    }
-}
-function withFormatting(text, edit, formattingOptions) {
-    let newText = applyEdit(text, edit);
-    let begin = edit.offset;
-    let end = edit.offset + edit.content.length;
-    if (edit.length === 0 || edit.content.length === 0) {
-        while (begin > 0 && !isEOL(newText, begin - 1)) {
-            begin--;
-        }
-        while (end < newText.length && !isEOL(newText, end)) {
-            end++;
-        }
-    }
-    const edits = format(newText, { offset: begin, length: end - begin }, formattingOptions);
-    for (let i = edits.length - 1; i >= 0; i--) {
-        const curr = edits[i];
-        newText = applyEdit(newText, curr);
-        begin = Math.min(begin, curr.offset);
-        end = Math.max(end, curr.offset + curr.length);
-        end += curr.content.length - curr.length;
-    }
-    const editLength = text.length - (newText.length - end) - begin;
-    return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
-}
-function applyEdit(text, edit) {
-    return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
-}
+import { refineServiceDecorator } from './polyfill.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 const FOLDER_CONFIG_FOLDER_NAME = '.vscode';
+const FOLDER_SETTINGS_NAME = 'settings';
+const FOLDER_SETTINGS_PATH = `${FOLDER_CONFIG_FOLDER_NAME}/${FOLDER_SETTINGS_NAME}.json`;
 const defaultSettingsSchemaId = 'vscode://schemas/settings/default';
 const userSettingsSchemaId = 'vscode://schemas/settings/user';
 const profileSettingsSchemaId = 'vscode://schemas/settings/profile';
@@ -329,6 +10,13 @@ const machineSettingsSchemaId = 'vscode://schemas/settings/machine';
 const workspaceSettingsSchemaId = 'vscode://schemas/settings/workspace';
 const folderSettingsSchemaId = 'vscode://schemas/settings/folder';
 const launchSchemaId = 'vscode://schemas/launch';
+const tasksSchemaId = 'vscode://schemas/tasks';
+const PROFILE_SCOPES = [2 , 3 , 4 , 5 , 6 ];
+const LOCAL_MACHINE_PROFILE_SCOPES = [3 , 4 , 5 ];
+const LOCAL_MACHINE_SCOPES = [1 , ...LOCAL_MACHINE_PROFILE_SCOPES];
+const REMOTE_MACHINE_SCOPES = [2 , 3 , 4 , 5 , 6 ];
+const WORKSPACE_SCOPES = [3 , 4 , 5 , 6 ];
+const FOLDER_SCOPES = [4 , 5 , 6 ];
 const TASKS_CONFIGURATION_KEY = 'tasks';
 const LAUNCH_CONFIGURATION_KEY = 'launch';
 const WORKSPACE_STANDALONE_CONFIGURATIONS = Object.create(null);
@@ -336,4 +24,6 @@ WORKSPACE_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${FOLDER_CONFIG_
 WORKSPACE_STANDALONE_CONFIGURATIONS[LAUNCH_CONFIGURATION_KEY] = `${FOLDER_CONFIG_FOLDER_NAME}/${LAUNCH_CONFIGURATION_KEY}.json`;
 const USER_STANDALONE_CONFIGURATIONS = Object.create(null);
 USER_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${TASKS_CONFIGURATION_KEY}.json`;
-export { defaultSettingsSchemaId as d, folderSettingsSchemaId as f, launchSchemaId as l, machineSettingsSchemaId as m, profileSettingsSchemaId as p, setProperty as s, userSettingsSchemaId as u, workspaceSettingsSchemaId as w };
+const IWorkbenchConfigurationService = refineServiceDecorator(IConfigurationService);
+const TASKS_DEFAULT = '{\n\t\"version\": \"2.0.0\",\n\t\"tasks\": []\n}';
+export { FOLDER_CONFIG_FOLDER_NAME, FOLDER_SCOPES, FOLDER_SETTINGS_NAME, FOLDER_SETTINGS_PATH, IWorkbenchConfigurationService, LAUNCH_CONFIGURATION_KEY, LOCAL_MACHINE_PROFILE_SCOPES, LOCAL_MACHINE_SCOPES, PROFILE_SCOPES, REMOTE_MACHINE_SCOPES, TASKS_CONFIGURATION_KEY, TASKS_DEFAULT, USER_STANDALONE_CONFIGURATIONS, WORKSPACE_SCOPES, WORKSPACE_STANDALONE_CONFIGURATIONS, defaultSettingsSchemaId, folderSettingsSchemaId, launchSchemaId, machineSettingsSchemaId, profileSettingsSchemaId, tasksSchemaId, userSettingsSchemaId, workspaceSettingsSchemaId };