🎉 initiate project *astro_rewrite*
This commit is contained in:
sindrekjelsrud
parent
ffd4d5e86c
commit
2ba37bfbe3
8658 changed files with 2268794 additions and 2538 deletions
490
node_modules/vscode-css-languageservice/lib/esm/services/selectorPrinting.js
generated
vendored
Normal file
490
node_modules/vscode-css-languageservice/lib/esm/services/selectorPrinting.js
generated
vendored
Normal file
|
|
@ -0,0 +1,490 @@
|
|||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
import * as nodes from '../parser/cssNodes';
|
||||
import { Scanner } from '../parser/cssScanner';
|
||||
import * as l10n from '@vscode/l10n';
|
||||
export class Element {
|
||||
constructor() {
|
||||
this.parent = null;
|
||||
this.children = null;
|
||||
this.attributes = null;
|
||||
}
|
||||
findAttribute(name) {
|
||||
if (this.attributes) {
|
||||
for (const attribute of this.attributes) {
|
||||
if (attribute.name === name) {
|
||||
return attribute.value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
addChild(child) {
|
||||
if (child instanceof Element) {
|
||||
child.parent = this;
|
||||
}
|
||||
if (!this.children) {
|
||||
this.children = [];
|
||||
}
|
||||
this.children.push(child);
|
||||
}
|
||||
append(text) {
|
||||
if (this.attributes) {
|
||||
const last = this.attributes[this.attributes.length - 1];
|
||||
last.value = last.value + text;
|
||||
}
|
||||
}
|
||||
prepend(text) {
|
||||
if (this.attributes) {
|
||||
const first = this.attributes[0];
|
||||
first.value = text + first.value;
|
||||
}
|
||||
}
|
||||
findRoot() {
|
||||
let curr = this;
|
||||
while (curr.parent && !(curr.parent instanceof RootElement)) {
|
||||
curr = curr.parent;
|
||||
}
|
||||
return curr;
|
||||
}
|
||||
removeChild(child) {
|
||||
if (this.children) {
|
||||
const index = this.children.indexOf(child);
|
||||
if (index !== -1) {
|
||||
this.children.splice(index, 1);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
addAttr(name, value) {
|
||||
if (!this.attributes) {
|
||||
this.attributes = [];
|
||||
}
|
||||
for (const attribute of this.attributes) {
|
||||
if (attribute.name === name) {
|
||||
attribute.value += ' ' + value;
|
||||
return;
|
||||
}
|
||||
}
|
||||
this.attributes.push({ name, value });
|
||||
}
|
||||
clone(cloneChildren = true) {
|
||||
const elem = new Element();
|
||||
if (this.attributes) {
|
||||
elem.attributes = [];
|
||||
for (const attribute of this.attributes) {
|
||||
elem.addAttr(attribute.name, attribute.value);
|
||||
}
|
||||
}
|
||||
if (cloneChildren && this.children) {
|
||||
elem.children = [];
|
||||
for (let index = 0; index < this.children.length; index++) {
|
||||
elem.addChild(this.children[index].clone());
|
||||
}
|
||||
}
|
||||
return elem;
|
||||
}
|
||||
cloneWithParent() {
|
||||
const clone = this.clone(false);
|
||||
if (this.parent && !(this.parent instanceof RootElement)) {
|
||||
const parentClone = this.parent.cloneWithParent();
|
||||
parentClone.addChild(clone);
|
||||
}
|
||||
return clone;
|
||||
}
|
||||
}
|
||||
export class RootElement extends Element {
|
||||
}
|
||||
export class LabelElement extends Element {
|
||||
constructor(label) {
|
||||
super();
|
||||
this.addAttr('name', label);
|
||||
}
|
||||
}
|
||||
class MarkedStringPrinter {
|
||||
constructor(quote) {
|
||||
this.quote = quote;
|
||||
this.result = [];
|
||||
// empty
|
||||
}
|
||||
print(element) {
|
||||
this.result = [];
|
||||
if (element instanceof RootElement) {
|
||||
if (element.children) {
|
||||
this.doPrint(element.children, 0);
|
||||
}
|
||||
}
|
||||
else {
|
||||
this.doPrint([element], 0);
|
||||
}
|
||||
const value = this.result.join('\n');
|
||||
return [{ language: 'html', value }];
|
||||
}
|
||||
doPrint(elements, indent) {
|
||||
for (const element of elements) {
|
||||
this.doPrintElement(element, indent);
|
||||
if (element.children) {
|
||||
this.doPrint(element.children, indent + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
writeLine(level, content) {
|
||||
const indent = new Array(level + 1).join(' ');
|
||||
this.result.push(indent + content);
|
||||
}
|
||||
doPrintElement(element, indent) {
|
||||
const name = element.findAttribute('name');
|
||||
// special case: a simple label
|
||||
if (element instanceof LabelElement || name === '\u2026') {
|
||||
this.writeLine(indent, name);
|
||||
return;
|
||||
}
|
||||
// the real deal
|
||||
const content = ['<'];
|
||||
// element name
|
||||
if (name) {
|
||||
content.push(name);
|
||||
}
|
||||
else {
|
||||
content.push('element');
|
||||
}
|
||||
// attributes
|
||||
if (element.attributes) {
|
||||
for (const attr of element.attributes) {
|
||||
if (attr.name !== 'name') {
|
||||
content.push(' ');
|
||||
content.push(attr.name);
|
||||
const value = attr.value;
|
||||
if (value) {
|
||||
content.push('=');
|
||||
content.push(quotes.ensure(value, this.quote));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
content.push('>');
|
||||
this.writeLine(indent, content.join(''));
|
||||
}
|
||||
}
|
||||
var quotes;
|
||||
(function (quotes) {
|
||||
function ensure(value, which) {
|
||||
return which + remove(value) + which;
|
||||
}
|
||||
quotes.ensure = ensure;
|
||||
function remove(value) {
|
||||
const match = value.match(/^['"](.*)["']$/);
|
||||
if (match) {
|
||||
return match[1];
|
||||
}
|
||||
return value;
|
||||
}
|
||||
quotes.remove = remove;
|
||||
})(quotes || (quotes = {}));
|
||||
class Specificity {
|
||||
constructor() {
|
||||
/** Count of identifiers (e.g., `#app`) */
|
||||
this.id = 0;
|
||||
/** Count of attributes (`[type="number"]`), classes (`.container-fluid`), and pseudo-classes (`:hover`) */
|
||||
this.attr = 0;
|
||||
/** Count of tag names (`div`), and pseudo-elements (`::before`) */
|
||||
this.tag = 0;
|
||||
}
|
||||
}
|
||||
export function toElement(node, parentElement) {
|
||||
let result = new Element();
|
||||
for (const child of node.getChildren()) {
|
||||
switch (child.type) {
|
||||
case nodes.NodeType.SelectorCombinator:
|
||||
if (parentElement) {
|
||||
const segments = child.getText().split('&');
|
||||
if (segments.length === 1) {
|
||||
// should not happen
|
||||
result.addAttr('name', segments[0]);
|
||||
break;
|
||||
}
|
||||
result = parentElement.cloneWithParent();
|
||||
if (segments[0]) {
|
||||
const root = result.findRoot();
|
||||
root.prepend(segments[0]);
|
||||
}
|
||||
for (let i = 1; i < segments.length; i++) {
|
||||
if (i > 1) {
|
||||
const clone = parentElement.cloneWithParent();
|
||||
result.addChild(clone.findRoot());
|
||||
result = clone;
|
||||
}
|
||||
result.append(segments[i]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case nodes.NodeType.SelectorPlaceholder:
|
||||
if (child.matches('@at-root')) {
|
||||
return result;
|
||||
}
|
||||
// fall through
|
||||
case nodes.NodeType.ElementNameSelector:
|
||||
const text = child.getText();
|
||||
result.addAttr('name', text === '*' ? 'element' : unescape(text));
|
||||
break;
|
||||
case nodes.NodeType.ClassSelector:
|
||||
result.addAttr('class', unescape(child.getText().substring(1)));
|
||||
break;
|
||||
case nodes.NodeType.IdentifierSelector:
|
||||
result.addAttr('id', unescape(child.getText().substring(1)));
|
||||
break;
|
||||
case nodes.NodeType.MixinDeclaration:
|
||||
result.addAttr('class', child.getName());
|
||||
break;
|
||||
case nodes.NodeType.PseudoSelector:
|
||||
result.addAttr(unescape(child.getText()), '');
|
||||
break;
|
||||
case nodes.NodeType.AttributeSelector:
|
||||
const selector = child;
|
||||
const identifier = selector.getIdentifier();
|
||||
if (identifier) {
|
||||
const expression = selector.getValue();
|
||||
const operator = selector.getOperator();
|
||||
let value;
|
||||
if (expression && operator) {
|
||||
switch (unescape(operator.getText())) {
|
||||
case '|=':
|
||||
// excatly or followed by -words
|
||||
value = `${quotes.remove(unescape(expression.getText()))}-\u2026`;
|
||||
break;
|
||||
case '^=':
|
||||
// prefix
|
||||
value = `${quotes.remove(unescape(expression.getText()))}\u2026`;
|
||||
break;
|
||||
case '$=':
|
||||
// suffix
|
||||
value = `\u2026${quotes.remove(unescape(expression.getText()))}`;
|
||||
break;
|
||||
case '~=':
|
||||
// one of a list of words
|
||||
value = ` \u2026 ${quotes.remove(unescape(expression.getText()))} \u2026 `;
|
||||
break;
|
||||
case '*=':
|
||||
// substring
|
||||
value = `\u2026${quotes.remove(unescape(expression.getText()))}\u2026`;
|
||||
break;
|
||||
default:
|
||||
value = quotes.remove(unescape(expression.getText()));
|
||||
break;
|
||||
}
|
||||
}
|
||||
result.addAttr(unescape(identifier.getText()), value);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function unescape(content) {
|
||||
const scanner = new Scanner();
|
||||
scanner.setSource(content);
|
||||
const token = scanner.scanUnquotedString();
|
||||
if (token) {
|
||||
return token.text;
|
||||
}
|
||||
return content;
|
||||
}
|
||||
export class SelectorPrinting {
|
||||
constructor(cssDataManager) {
|
||||
this.cssDataManager = cssDataManager;
|
||||
}
|
||||
selectorToMarkedString(node) {
|
||||
const root = selectorToElement(node);
|
||||
if (root) {
|
||||
const markedStrings = new MarkedStringPrinter('"').print(root);
|
||||
markedStrings.push(this.selectorToSpecificityMarkedString(node));
|
||||
return markedStrings;
|
||||
}
|
||||
else {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
simpleSelectorToMarkedString(node) {
|
||||
const element = toElement(node);
|
||||
const markedStrings = new MarkedStringPrinter('"').print(element);
|
||||
markedStrings.push(this.selectorToSpecificityMarkedString(node));
|
||||
return markedStrings;
|
||||
}
|
||||
isPseudoElementIdentifier(text) {
|
||||
const match = text.match(/^::?([\w-]+)/);
|
||||
if (!match) {
|
||||
return false;
|
||||
}
|
||||
return !!this.cssDataManager.getPseudoElement("::" + match[1]);
|
||||
}
|
||||
selectorToSpecificityMarkedString(node) {
|
||||
//https://www.w3.org/TR/selectors-3/#specificity
|
||||
const calculateScore = (node) => {
|
||||
const specificity = new Specificity();
|
||||
elementLoop: for (const element of node.getChildren()) {
|
||||
switch (element.type) {
|
||||
case nodes.NodeType.IdentifierSelector:
|
||||
specificity.id++;
|
||||
break;
|
||||
case nodes.NodeType.ClassSelector:
|
||||
case nodes.NodeType.AttributeSelector:
|
||||
specificity.attr++;
|
||||
break;
|
||||
case nodes.NodeType.ElementNameSelector:
|
||||
//ignore universal selector
|
||||
if (element.matches("*")) {
|
||||
break;
|
||||
}
|
||||
specificity.tag++;
|
||||
break;
|
||||
case nodes.NodeType.PseudoSelector:
|
||||
const text = element.getText();
|
||||
if (this.isPseudoElementIdentifier(text)) {
|
||||
specificity.tag++; // pseudo element
|
||||
continue elementLoop;
|
||||
}
|
||||
// where and child selectors have zero specificity
|
||||
if (text.match(/^:where/i)) {
|
||||
continue elementLoop;
|
||||
}
|
||||
// the most specific child selector
|
||||
if (text.match(/^:(not|has|is)/i) && element.getChildren().length > 0) {
|
||||
let mostSpecificListItem = new Specificity();
|
||||
for (const containerElement of element.getChildren()) {
|
||||
let list;
|
||||
if (containerElement.type === nodes.NodeType.Undefined) { // containerElement is a list of selectors
|
||||
list = containerElement.getChildren();
|
||||
}
|
||||
else { // containerElement is a selector
|
||||
list = [containerElement];
|
||||
}
|
||||
for (const childElement of containerElement.getChildren()) {
|
||||
const itemSpecificity = calculateScore(childElement);
|
||||
if (itemSpecificity.id > mostSpecificListItem.id) {
|
||||
mostSpecificListItem = itemSpecificity;
|
||||
continue;
|
||||
}
|
||||
else if (itemSpecificity.id < mostSpecificListItem.id) {
|
||||
continue;
|
||||
}
|
||||
if (itemSpecificity.attr > mostSpecificListItem.attr) {
|
||||
mostSpecificListItem = itemSpecificity;
|
||||
continue;
|
||||
}
|
||||
else if (itemSpecificity.attr < mostSpecificListItem.attr) {
|
||||
continue;
|
||||
}
|
||||
if (itemSpecificity.tag > mostSpecificListItem.tag) {
|
||||
mostSpecificListItem = itemSpecificity;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
specificity.id += mostSpecificListItem.id;
|
||||
specificity.attr += mostSpecificListItem.attr;
|
||||
specificity.tag += mostSpecificListItem.tag;
|
||||
continue elementLoop;
|
||||
}
|
||||
specificity.attr++; //pseudo class
|
||||
continue elementLoop;
|
||||
}
|
||||
if (element.getChildren().length > 0) {
|
||||
const itemSpecificity = calculateScore(element);
|
||||
specificity.id += itemSpecificity.id;
|
||||
specificity.attr += itemSpecificity.attr;
|
||||
specificity.tag += itemSpecificity.tag;
|
||||
}
|
||||
}
|
||||
return specificity;
|
||||
};
|
||||
const specificity = calculateScore(node);
|
||||
return `[${l10n.t("Selector Specificity")}](https://developer.mozilla.org/docs/Web/CSS/Specificity): (${specificity.id}, ${specificity.attr}, ${specificity.tag})`;
|
||||
}
|
||||
}
|
||||
class SelectorElementBuilder {
|
||||
constructor(element) {
|
||||
this.prev = null;
|
||||
this.element = element;
|
||||
}
|
||||
processSelector(selector) {
|
||||
let parentElement = null;
|
||||
if (!(this.element instanceof RootElement)) {
|
||||
if (selector.getChildren().some((c) => c.hasChildren() && c.getChild(0).type === nodes.NodeType.SelectorCombinator)) {
|
||||
const curr = this.element.findRoot();
|
||||
if (curr.parent instanceof RootElement) {
|
||||
parentElement = this.element;
|
||||
this.element = curr.parent;
|
||||
this.element.removeChild(curr);
|
||||
this.prev = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const selectorChild of selector.getChildren()) {
|
||||
if (selectorChild instanceof nodes.SimpleSelector) {
|
||||
if (this.prev instanceof nodes.SimpleSelector) {
|
||||
const labelElement = new LabelElement('\u2026');
|
||||
this.element.addChild(labelElement);
|
||||
this.element = labelElement;
|
||||
}
|
||||
else if (this.prev && (this.prev.matches('+') || this.prev.matches('~')) && this.element.parent) {
|
||||
this.element = this.element.parent;
|
||||
}
|
||||
if (this.prev && this.prev.matches('~')) {
|
||||
this.element.addChild(new LabelElement('\u22EE'));
|
||||
}
|
||||
const thisElement = toElement(selectorChild, parentElement);
|
||||
const root = thisElement.findRoot();
|
||||
this.element.addChild(root);
|
||||
this.element = thisElement;
|
||||
}
|
||||
if (selectorChild instanceof nodes.SimpleSelector ||
|
||||
selectorChild.type === nodes.NodeType.SelectorCombinatorParent ||
|
||||
selectorChild.type === nodes.NodeType.SelectorCombinatorShadowPiercingDescendant ||
|
||||
selectorChild.type === nodes.NodeType.SelectorCombinatorSibling ||
|
||||
selectorChild.type === nodes.NodeType.SelectorCombinatorAllSiblings) {
|
||||
this.prev = selectorChild;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function isNewSelectorContext(node) {
|
||||
switch (node.type) {
|
||||
case nodes.NodeType.MixinDeclaration:
|
||||
case nodes.NodeType.Stylesheet:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function selectorToElement(node) {
|
||||
if (node.matches('@at-root')) {
|
||||
return null;
|
||||
}
|
||||
const root = new RootElement();
|
||||
const parentRuleSets = [];
|
||||
const ruleSet = node.getParent();
|
||||
if (ruleSet instanceof nodes.RuleSet) {
|
||||
let parent = ruleSet.getParent(); // parent of the selector's ruleset
|
||||
while (parent && !isNewSelectorContext(parent)) {
|
||||
if (parent instanceof nodes.RuleSet) {
|
||||
if (parent.getSelectors().matches('@at-root')) {
|
||||
break;
|
||||
}
|
||||
parentRuleSets.push(parent);
|
||||
}
|
||||
parent = parent.getParent();
|
||||
}
|
||||
}
|
||||
const builder = new SelectorElementBuilder(root);
|
||||
for (let i = parentRuleSets.length - 1; i >= 0; i--) {
|
||||
const selector = parentRuleSets[i].getSelectors().getChild(0);
|
||||
if (selector) {
|
||||
builder.processSelector(selector);
|
||||
}
|
||||
}
|
||||
builder.processSelector(node);
|
||||
return root;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue