monaco-editor11 1.1.2 → 1.1.4

package/dist/esm/monaco-editor/esm/external/vscode-css-languageservice/lib/esm/services/lintUtil.js

@@ -0,0 +1,198 @@
+import { includes } from '../utils/arrays.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Element {
+    constructor(decl) {
+        this.fullPropertyName = decl.getFullPropertyName().toLowerCase();
+        this.node = decl;
+    }
+}
+function setSide(model, side, value, property) {
+    const state = model[side];
+    state.value = value;
+    if (value) {
+        if (!includes(state.properties, property)) {
+            state.properties.push(property);
+        }
+    }
+}
+function setAllSides(model, value, property) {
+    setSide(model, 'top', value, property);
+    setSide(model, 'right', value, property);
+    setSide(model, 'bottom', value, property);
+    setSide(model, 'left', value, property);
+}
+function updateModelWithValue(model, side, value, property) {
+    if (side === 'top' || side === 'right' ||
+        side === 'bottom' || side === 'left') {
+        setSide(model, side, value, property);
+    }
+    else {
+        setAllSides(model, value, property);
+    }
+}
+function updateModelWithList(model, values, property) {
+    switch (values.length) {
+        case 1:
+            updateModelWithValue(model, undefined, values[0], property);
+            break;
+        case 2:
+            updateModelWithValue(model, 'top', values[0], property);
+            updateModelWithValue(model, 'bottom', values[0], property);
+            updateModelWithValue(model, 'right', values[1], property);
+            updateModelWithValue(model, 'left', values[1], property);
+            break;
+        case 3:
+            updateModelWithValue(model, 'top', values[0], property);
+            updateModelWithValue(model, 'right', values[1], property);
+            updateModelWithValue(model, 'left', values[1], property);
+            updateModelWithValue(model, 'bottom', values[2], property);
+            break;
+        case 4:
+            updateModelWithValue(model, 'top', values[0], property);
+            updateModelWithValue(model, 'right', values[1], property);
+            updateModelWithValue(model, 'bottom', values[2], property);
+            updateModelWithValue(model, 'left', values[3], property);
+            break;
+    }
+}
+function matches(value, candidates) {
+    for (let candidate of candidates) {
+        if (value.matches(candidate)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @param allowsKeywords whether the initial value of property is zero, so keywords `initial` and `unset` count as zero
+ * @return `true` if this node represents a non-zero border; otherwise, `false`
+ */
+function checkLineWidth(value, allowsKeywords = true) {
+    if (allowsKeywords && matches(value, ['initial', 'unset'])) {
+        return false;
+    }
+    // a <length> is a value and a unit
+    // so use `parseFloat` to strip the unit
+    return parseFloat(value.getText()) !== 0;
+}
+function checkLineWidthList(nodes, allowsKeywords = true) {
+    return nodes.map(node => checkLineWidth(node, allowsKeywords));
+}
+/**
+ * @param allowsKeywords whether keywords `initial` and `unset` count as zero
+ * @return `true` if this node represents a non-zero border; otherwise, `false`
+ */
+function checkLineStyle(valueNode, allowsKeywords = true) {
+    if (matches(valueNode, ['none', 'hidden'])) {
+        return false;
+    }
+    if (allowsKeywords && matches(valueNode, ['initial', 'unset'])) {
+        return false;
+    }
+    return true;
+}
+function checkLineStyleList(nodes, allowsKeywords = true) {
+    return nodes.map(node => checkLineStyle(node, allowsKeywords));
+}
+function checkBorderShorthand(node) {
+    const children = node.getChildren();
+    // the only child can be a keyword, a <line-width>, or a <line-style>
+    // if either check returns false, the result is no border
+    if (children.length === 1) {
+        const value = children[0];
+        return checkLineWidth(value) && checkLineStyle(value);
+    }
+    // multiple children can't contain keywords
+    // if any child means no border, the result is no border
+    for (const child of children) {
+        const value = child;
+        if (!checkLineWidth(value, /* allowsKeywords: */ false) ||
+            !checkLineStyle(value, /* allowsKeywords: */ false)) {
+            return false;
+        }
+    }
+    return true;
+}
+function calculateBoxModel(propertyTable) {
+    const model = {
+        top: { value: false, properties: [] },
+        right: { value: false, properties: [] },
+        bottom: { value: false, properties: [] },
+        left: { value: false, properties: [] },
+    };
+    for (const property of propertyTable) {
+        const value = property.node.value;
+        if (typeof value === 'undefined') {
+            continue;
+        }
+        switch (property.fullPropertyName) {
+            case 'box-sizing':
+                // has `box-sizing`, bail out
+                return {
+                    top: { value: false, properties: [] },
+                    right: { value: false, properties: [] },
+                    bottom: { value: false, properties: [] },
+                    left: { value: false, properties: [] },
+                };
+            case 'width':
+                model.width = property;
+                break;
+            case 'height':
+                model.height = property;
+                break;
+            default:
+                const segments = property.fullPropertyName.split('-');
+                switch (segments[0]) {
+                    case 'border':
+                        switch (segments[1]) {
+                            case undefined:
+                            case 'top':
+                            case 'right':
+                            case 'bottom':
+                            case 'left':
+                                switch (segments[2]) {
+                                    case undefined:
+                                        updateModelWithValue(model, segments[1], checkBorderShorthand(value), property);
+                                        break;
+                                    case 'width':
+                                        // the initial value of `border-width` is `medium`, not zero
+                                        updateModelWithValue(model, segments[1], checkLineWidth(value, false), property);
+                                        break;
+                                    case 'style':
+                                        // the initial value of `border-style` is `none`
+                                        updateModelWithValue(model, segments[1], checkLineStyle(value, true), property);
+                                        break;
+                                }
+                                break;
+                            case 'width':
+                                // the initial value of `border-width` is `medium`, not zero
+                                updateModelWithList(model, checkLineWidthList(value.getChildren(), false), property);
+                                break;
+                            case 'style':
+                                // the initial value of `border-style` is `none`
+                                updateModelWithList(model, checkLineStyleList(value.getChildren(), true), property);
+                                break;
+                        }
+                        break;
+                    case 'padding':
+                        if (segments.length === 1) {
+                            // the initial value of `padding` is zero
+                            updateModelWithList(model, checkLineWidthList(value.getChildren(), true), property);
+                        }
+                        else {
+                            // the initial value of `padding` is zero
+                            updateModelWithValue(model, segments[1], checkLineWidth(value, true), property);
+                        }
+                        break;
+                }
+                break;
+        }
+    }
+    return model;
+}
+
+export { Element, calculateBoxModel as default };

package/dist/esm/monaco-editor/esm/external/vscode-css-languageservice/lib/esm/services/pathCompletion.js

@@ -0,0 +1,161 @@
+import { FileType } from '../cssLanguageTypes.js';
+import { startsWith, endsWith } from '../utils/strings.js';
+import { joinPath } from '../utils/resources.js';
+import { Range, TextEdit, CompletionItemKind, Position } from '../../../../vscode-languageserver-types/lib/esm/main.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class PathCompletionParticipant {
+    constructor(readDirectory) {
+        this.readDirectory = readDirectory;
+        this.literalCompletions = [];
+        this.importCompletions = [];
+    }
+    onCssURILiteralValue(context) {
+        this.literalCompletions.push(context);
+    }
+    onCssImportPath(context) {
+        this.importCompletions.push(context);
+    }
+    async computeCompletions(document, documentContext) {
+        const result = { items: [], isIncomplete: false };
+        for (const literalCompletion of this.literalCompletions) {
+            const uriValue = literalCompletion.uriValue;
+            const fullValue = stripQuotes(uriValue);
+            if (fullValue === '.' || fullValue === '..') {
+                result.isIncomplete = true;
+            }
+            else {
+                const items = await this.providePathSuggestions(uriValue, literalCompletion.position, literalCompletion.range, document, documentContext);
+                for (let item of items) {
+                    result.items.push(item);
+                }
+            }
+        }
+        for (const importCompletion of this.importCompletions) {
+            const pathValue = importCompletion.pathValue;
+            const fullValue = stripQuotes(pathValue);
+            if (fullValue === '.' || fullValue === '..') {
+                result.isIncomplete = true;
+            }
+            else {
+                let suggestions = await this.providePathSuggestions(pathValue, importCompletion.position, importCompletion.range, document, documentContext);
+                if (document.languageId === 'scss') {
+                    suggestions.forEach(s => {
+                        if (startsWith(s.label, '_') && endsWith(s.label, '.scss')) {
+                            if (s.textEdit) {
+                                s.textEdit.newText = s.label.slice(1, -5);
+                            }
+                            else {
+                                s.label = s.label.slice(1, -5);
+                            }
+                        }
+                    });
+                }
+                for (let item of suggestions) {
+                    result.items.push(item);
+                }
+            }
+        }
+        return result;
+    }
+    async providePathSuggestions(pathValue, position, range, document, documentContext) {
+        const fullValue = stripQuotes(pathValue);
+        const isValueQuoted = startsWith(pathValue, `'`) || startsWith(pathValue, `"`);
+        const valueBeforeCursor = isValueQuoted
+            ? fullValue.slice(0, position.character - (range.start.character + 1))
+            : fullValue.slice(0, position.character - range.start.character);
+        const currentDocUri = document.uri;
+        const fullValueRange = isValueQuoted ? shiftRange(range, 1, -1) : range;
+        const replaceRange = pathToReplaceRange(valueBeforeCursor, fullValue, fullValueRange);
+        const valueBeforeLastSlash = valueBeforeCursor.substring(0, valueBeforeCursor.lastIndexOf('/') + 1); // keep the last slash
+        let parentDir = documentContext.resolveReference(valueBeforeLastSlash || '.', currentDocUri);
+        if (parentDir) {
+            try {
+                const result = [];
+                const infos = await this.readDirectory(parentDir);
+                for (const [name, type] of infos) {
+                    // Exclude paths that start with `.`
+                    if (name.charCodeAt(0) !== CharCode_dot && (type === FileType.Directory || joinPath(parentDir, name) !== currentDocUri)) {
+                        result.push(createCompletionItem(name, type === FileType.Directory, replaceRange));
+                    }
+                }
+                return result;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        return [];
+    }
+}
+const CharCode_dot = '.'.charCodeAt(0);
+function stripQuotes(fullValue) {
+    if (startsWith(fullValue, `'`) || startsWith(fullValue, `"`)) {
+        return fullValue.slice(1, -1);
+    }
+    else {
+        return fullValue;
+    }
+}
+function pathToReplaceRange(valueBeforeCursor, fullValue, fullValueRange) {
+    let replaceRange;
+    const lastIndexOfSlash = valueBeforeCursor.lastIndexOf('/');
+    if (lastIndexOfSlash === -1) {
+        replaceRange = fullValueRange;
+    }
+    else {
+        // For cases where cursor is in the middle of attribute value, like <script src="./s|rc/test.js">
+        // Find the last slash before cursor, and calculate the start of replace range from there
+        const valueAfterLastSlash = fullValue.slice(lastIndexOfSlash + 1);
+        const startPos = shiftPosition(fullValueRange.end, -valueAfterLastSlash.length);
+        // If whitespace exists, replace until it
+        const whitespaceIndex = valueAfterLastSlash.indexOf(' ');
+        let endPos;
+        if (whitespaceIndex !== -1) {
+            endPos = shiftPosition(startPos, whitespaceIndex);
+        }
+        else {
+            endPos = fullValueRange.end;
+        }
+        replaceRange = Range.create(startPos, endPos);
+    }
+    return replaceRange;
+}
+function createCompletionItem(name, isDir, replaceRange) {
+    if (isDir) {
+        name = name + '/';
+        return {
+            label: escapePath(name),
+            kind: CompletionItemKind.Folder,
+            textEdit: TextEdit.replace(replaceRange, escapePath(name)),
+            command: {
+                title: 'Suggest',
+                command: 'editor.action.triggerSuggest'
+            }
+        };
+    }
+    else {
+        return {
+            label: escapePath(name),
+            kind: CompletionItemKind.File,
+            textEdit: TextEdit.replace(replaceRange, escapePath(name))
+        };
+    }
+}
+// Escape https://www.w3.org/TR/CSS1/#url
+function escapePath(p) {
+    return p.replace(/(\s|\(|\)|,|"|')/g, '\\$1');
+}
+function shiftPosition(pos, offset) {
+    return Position.create(pos.line, pos.character + offset);
+}
+function shiftRange(range, startOffset, endOffset) {
+    const start = shiftPosition(range.start, startOffset);
+    const end = shiftPosition(range.end, endOffset);
+    return Range.create(start, end);
+}
+
+export { PathCompletionParticipant };