vscode-css-languageservice 6.3.10 → 7.0.0-next.1

package/lib/umd/services/lintRules.js

@@ -1,90 +0,0 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../parser/cssNodes", "@vscode/l10n"], factory);
-    }
-})(function (require, exports) {
-    /*---------------------------------------------------------------------------------------------
-     *  Copyright (c) Microsoft Corporation. All rights reserved.
-     *  Licensed under the MIT License. See License.txt in the project root for license information.
-     *--------------------------------------------------------------------------------------------*/
-    'use strict';
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.LintConfigurationSettings = exports.Settings = exports.Rules = exports.Setting = exports.Rule = void 0;
-    const nodes = require("../parser/cssNodes");
-    const l10n = require("@vscode/l10n");
-    const Warning = nodes.Level.Warning;
-    const Error = nodes.Level.Error;
-    const Ignore = nodes.Level.Ignore;
-    class Rule {
-        constructor(id, message, defaultValue) {
-            this.id = id;
-            this.message = message;
-            this.defaultValue = defaultValue;
-            // nothing to do
-        }
-    }
-    exports.Rule = Rule;
-    class Setting {
-        constructor(id, message, defaultValue) {
-            this.id = id;
-            this.message = message;
-            this.defaultValue = defaultValue;
-            // nothing to do
-        }
-    }
-    exports.Setting = Setting;
-    exports.Rules = {
-        AllVendorPrefixes: new Rule('compatibleVendorPrefixes', l10n.t("When using a vendor-specific prefix make sure to also include all other vendor-specific properties"), Ignore),
-        IncludeStandardPropertyWhenUsingVendorPrefix: new Rule('vendorPrefix', l10n.t("When using a vendor-specific prefix also include the standard property"), Warning),
-        DuplicateDeclarations: new Rule('duplicateProperties', l10n.t("Do not use duplicate style definitions"), Ignore),
-        EmptyRuleSet: new Rule('emptyRules', l10n.t("Do not use empty rulesets"), Warning),
-        ImportStatemement: new Rule('importStatement', l10n.t("Import statements do not load in parallel"), Ignore),
-        BewareOfBoxModelSize: new Rule('boxModel', l10n.t("Do not use width or height when using padding or border"), Ignore),
-        UniversalSelector: new Rule('universalSelector', l10n.t("The universal selector (*) is known to be slow"), Ignore),
-        ZeroWithUnit: new Rule('zeroUnits', l10n.t("No unit for zero needed"), Ignore),
-        RequiredPropertiesForFontFace: new Rule('fontFaceProperties', l10n.t("@font-face rule must define 'src' and 'font-family' properties"), Warning),
-        HexColorLength: new Rule('hexColorLength', l10n.t("Hex colors must consist of three, four, six or eight hex numbers"), Error),
-        ArgsInColorFunction: new Rule('argumentsInColorFunction', l10n.t("Invalid number of parameters"), Error),
-        UnknownProperty: new Rule('unknownProperties', l10n.t("Unknown property."), Warning),
-        UnknownAtRules: new Rule('unknownAtRules', l10n.t("Unknown at-rule."), Warning),
-        IEStarHack: new Rule('ieHack', l10n.t("IE hacks are only necessary when supporting IE7 and older"), Ignore),
-        UnknownVendorSpecificProperty: new Rule('unknownVendorSpecificProperties', l10n.t("Unknown vendor specific property."), Ignore),
-        PropertyIgnoredDueToDisplay: new Rule('propertyIgnoredDueToDisplay', l10n.t("Property is ignored due to the display."), Warning),
-        AvoidImportant: new Rule('important', l10n.t("Avoid using !important. It is an indication that the specificity of the entire CSS has gotten out of control and needs to be refactored."), Ignore),
-        AvoidFloat: new Rule('float', l10n.t("Avoid using 'float'. Floats lead to fragile CSS that is easy to break if one aspect of the layout changes."), Ignore),
-        AvoidIdSelector: new Rule('idSelector', l10n.t("Selectors should not contain IDs because these rules are too tightly coupled with the HTML."), Ignore),
-    };
-    exports.Settings = {
-        ValidProperties: new Setting('validProperties', l10n.t("A list of properties that are not validated against the `unknownProperties` rule."), [])
-    };
-    class LintConfigurationSettings {
-        constructor(conf = {}) {
-            this.conf = conf;
-        }
-        getRule(rule) {
-            if (this.conf.hasOwnProperty(rule.id)) {
-                const level = toLevel(this.conf[rule.id]);
-                if (level) {
-                    return level;
-                }
-            }
-            return rule.defaultValue;
-        }
-        getSetting(setting) {
-            return this.conf[setting.id];
-        }
-    }
-    exports.LintConfigurationSettings = LintConfigurationSettings;
-    function toLevel(level) {
-        switch (level) {
-            case 'ignore': return nodes.Level.Ignore;
-            case 'warning': return nodes.Level.Warning;
-            case 'error': return nodes.Level.Error;
-        }
-        return null;
-    }
-});

package/lib/umd/services/lintUtil.js

@@ -1,210 +0,0 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../utils/arrays"], factory);
-    }
-})(function (require, exports) {
-    /*---------------------------------------------------------------------------------------------
-     *  Copyright (c) Microsoft Corporation. All rights reserved.
-     *  Licensed under the MIT License. See License.txt in the project root for license information.
-     *--------------------------------------------------------------------------------------------*/
-    'use strict';
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Element = void 0;
-    exports.default = calculateBoxModel;
-    const arrays_1 = require("../utils/arrays");
-    class Element {
-        constructor(decl) {
-            this.fullPropertyName = decl.getFullPropertyName().toLowerCase();
-            this.node = decl;
-        }
-    }
-    exports.Element = Element;
-    function setSide(model, side, value, property) {
-        const state = model[side];
-        state.value = value;
-        if (value) {
-            if (!(0, arrays_1.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;
-    }
-});

package/lib/umd/services/pathCompletion.js

@@ -1,171 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../cssLanguageTypes", "../utils/strings", "../utils/resources"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.PathCompletionParticipant = void 0;
-    const cssLanguageTypes_1 = require("../cssLanguageTypes");
-    const strings_1 = require("../utils/strings");
-    const resources_1 = require("../utils/resources");
-    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 ((0, strings_1.startsWith)(s.label, '_') && (0, strings_1.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 = (0, strings_1.startsWith)(pathValue, `'`) || (0, strings_1.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 === cssLanguageTypes_1.FileType.Directory || (0, resources_1.joinPath)(parentDir, name) !== currentDocUri)) {
-                            result.push(createCompletionItem(name, type === cssLanguageTypes_1.FileType.Directory, replaceRange));
-                        }
-                    }
-                    return result;
-                }
-                catch (e) {
-                    // ignore
-                }
-            }
-            return [];
-        }
-    }
-    exports.PathCompletionParticipant = PathCompletionParticipant;
-    const CharCode_dot = '.'.charCodeAt(0);
-    function stripQuotes(fullValue) {
-        if ((0, strings_1.startsWith)(fullValue, `'`) || (0, strings_1.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 = cssLanguageTypes_1.Range.create(startPos, endPos);
-        }
-        return replaceRange;
-    }
-    function createCompletionItem(name, isDir, replaceRange) {
-        if (isDir) {
-            name = name + '/';
-            return {
-                label: escapePath(name),
-                kind: cssLanguageTypes_1.CompletionItemKind.Folder,
-                textEdit: cssLanguageTypes_1.TextEdit.replace(replaceRange, escapePath(name)),
-                command: {
-                    title: 'Suggest',
-                    command: 'editor.action.triggerSuggest'
-                }
-            };
-        }
-        else {
-            return {
-                label: escapePath(name),
-                kind: cssLanguageTypes_1.CompletionItemKind.File,
-                textEdit: cssLanguageTypes_1.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 cssLanguageTypes_1.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 cssLanguageTypes_1.Range.create(start, end);
-    }
-});