471 lines
15 KiB
JavaScript
471 lines
15 KiB
JavaScript
|
'use strict';
|
||
|
|
|
||
|
|
const error = require('./error.cjs');
|
||
|
|
const names = require('../utils/names.cjs');
|
||
|
|
const genericConst = require('./generic-const.cjs');
|
||
|
|
const generic = require('./generic.cjs');
|
||
|
|
const units = require('./units.cjs');
|
||
|
|
const prepareTokens = require('./prepare-tokens.cjs');
|
||
|
|
const matchGraph = require('./match-graph.cjs');
|
||
|
|
const match = require('./match.cjs');
|
||
|
|
const trace = require('./trace.cjs');
|
||
|
|
const search = require('./search.cjs');
|
||
|
|
const structure = require('./structure.cjs');
|
||
|
|
const parse = require('../definition-syntax/parse.cjs');
|
||
|
|
const generate = require('../definition-syntax/generate.cjs');
|
||
|
|
const walk = require('../definition-syntax/walk.cjs');
|
||
|
|
|
||
|
|
const cssWideKeywordsSyntax = matchGraph.buildMatchGraph(genericConst.cssWideKeywords.join(' | '));
|
||
|
|
|
||
|
|
function dumpMapSyntax(map, compact, syntaxAsAst) {
|
||
|
|
const result = {};
|
||
|
|
|
||
|
|
for (const name in map) {
|
||
|
|
if (map[name].syntax) {
|
||
|
|
result[name] = syntaxAsAst
|
||
|
|
? map[name].syntax
|
||
|
|
: generate.generate(map[name].syntax, { compact });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
function dumpAtruleMapSyntax(map, compact, syntaxAsAst) {
|
||
|
|
const result = {};
|
||
|
|
|
||
|
|
for (const [name, atrule] of Object.entries(map)) {
|
||
|
|
result[name] = {
|
||
|
|
prelude: atrule.prelude && (
|
||
|
|
syntaxAsAst
|
||
|
|
? atrule.prelude.syntax
|
||
|
|
: generate.generate(atrule.prelude.syntax, { compact })
|
||
|
|
),
|
||
|
|
descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
function valueHasVar(tokens) {
|
||
|
|
for (let i = 0; i < tokens.length; i++) {
|
||
|
|
if (tokens[i].value.toLowerCase() === 'var(') {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function buildMatchResult(matched, error, iterations) {
|
||
|
|
return {
|
||
|
|
matched,
|
||
|
|
iterations,
|
||
|
|
error,
|
||
|
|
...trace
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function matchSyntax(lexer, syntax, value, useCssWideKeywords) {
|
||
|
|
const tokens = prepareTokens(value, lexer.syntax);
|
||
|
|
let result;
|
||
|
|
|
||
|
|
if (valueHasVar(tokens)) {
|
||
|
|
return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (useCssWideKeywords) {
|
||
|
|
result = match.matchAsTree(tokens, lexer.cssWideKeywordsSyntax, lexer);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!useCssWideKeywords || !result.match) {
|
||
|
|
result = match.matchAsTree(tokens, syntax.match, lexer);
|
||
|
|
if (!result.match) {
|
||
|
|
return buildMatchResult(
|
||
|
|
null,
|
||
|
|
new error.SyntaxMatchError(result.reason, syntax.syntax, value, result),
|
||
|
|
result.iterations
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return buildMatchResult(result.match, null, result.iterations);
|
||
|
|
}
|
||
|
|
|
||
|
|
class Lexer {
|
||
|
|
constructor(config, syntax, structure$1) {
|
||
|
|
this.cssWideKeywordsSyntax = cssWideKeywordsSyntax;
|
||
|
|
this.syntax = syntax;
|
||
|
|
this.generic = false;
|
||
|
|
this.units = { ...units };
|
||
|
|
this.atrules = Object.create(null);
|
||
|
|
this.properties = Object.create(null);
|
||
|
|
this.types = Object.create(null);
|
||
|
|
this.structure = structure$1 || structure.getStructureFromConfig(config);
|
||
|
|
|
||
|
|
if (config) {
|
||
|
|
if (config.units) {
|
||
|
|
for (const group of Object.keys(units)) {
|
||
|
|
if (Array.isArray(config.units[group])) {
|
||
|
|
this.units[group] = config.units[group];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.types) {
|
||
|
|
for (const name in config.types) {
|
||
|
|
this.addType_(name, config.types[name]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.generic) {
|
||
|
|
this.generic = true;
|
||
|
|
for (const [name, value] of Object.entries(generic.createGenericTypes(this.units))) {
|
||
|
|
this.addType_(name, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.atrules) {
|
||
|
|
for (const name in config.atrules) {
|
||
|
|
this.addAtrule_(name, config.atrules[name]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.properties) {
|
||
|
|
for (const name in config.properties) {
|
||
|
|
this.addProperty_(name, config.properties[name]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
checkStructure(ast) {
|
||
|
|
function collectWarning(node, message) {
|
||
|
|
warns.push({ node, message });
|
||
|
|
}
|
||
|
|
|
||
|
|
const structure = this.structure;
|
||
|
|
const warns = [];
|
||
|
|
|
||
|
|
this.syntax.walk(ast, function(node) {
|
||
|
|
if (structure.hasOwnProperty(node.type)) {
|
||
|
|
structure[node.type].check(node, collectWarning);
|
||
|
|
} else {
|
||
|
|
collectWarning(node, 'Unknown node type `' + node.type + '`');
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
return warns.length ? warns : false;
|
||
|
|
}
|
||
|
|
|
||
|
|
createDescriptor(syntax, type, name, parent = null) {
|
||
|
|
const ref = {
|
||
|
|
type,
|
||
|
|
name
|
||
|
|
};
|
||
|
|
const descriptor = {
|
||
|
|
type,
|
||
|
|
name,
|
||
|
|
parent,
|
||
|
|
serializable: typeof syntax === 'string' || (syntax && typeof syntax.type === 'string'),
|
||
|
|
syntax: null,
|
||
|
|
match: null
|
||
|
|
};
|
||
|
|
|
||
|
|
if (typeof syntax === 'function') {
|
||
|
|
descriptor.match = matchGraph.buildMatchGraph(syntax, ref);
|
||
|
|
} else {
|
||
|
|
if (typeof syntax === 'string') {
|
||
|
|
// lazy parsing on first access
|
||
|
|
Object.defineProperty(descriptor, 'syntax', {
|
||
|
|
get() {
|
||
|
|
Object.defineProperty(descriptor, 'syntax', {
|
||
|
|
value: parse.parse(syntax)
|
||
|
|
});
|
||
|
|
|
||
|
|
return descriptor.syntax;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
descriptor.syntax = syntax;
|
||
|
|
}
|
||
|
|
|
||
|
|
// lazy graph build on first access
|
||
|
|
Object.defineProperty(descriptor, 'match', {
|
||
|
|
get() {
|
||
|
|
Object.defineProperty(descriptor, 'match', {
|
||
|
|
value: matchGraph.buildMatchGraph(descriptor.syntax, ref)
|
||
|
|
});
|
||
|
|
|
||
|
|
return descriptor.match;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return descriptor;
|
||
|
|
}
|
||
|
|
addAtrule_(name, syntax) {
|
||
|
|
if (!syntax) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.atrules[name] = {
|
||
|
|
type: 'Atrule',
|
||
|
|
name: name,
|
||
|
|
prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, 'AtrulePrelude', name) : null,
|
||
|
|
descriptors: syntax.descriptors
|
||
|
|
? Object.keys(syntax.descriptors).reduce(
|
||
|
|
(map, descName) => {
|
||
|
|
map[descName] = this.createDescriptor(syntax.descriptors[descName], 'AtruleDescriptor', descName, name);
|
||
|
|
return map;
|
||
|
|
},
|
||
|
|
Object.create(null)
|
||
|
|
)
|
||
|
|
: null
|
||
|
|
};
|
||
|
|
}
|
||
|
|
addProperty_(name, syntax) {
|
||
|
|
if (!syntax) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.properties[name] = this.createDescriptor(syntax, 'Property', name);
|
||
|
|
}
|
||
|
|
addType_(name, syntax) {
|
||
|
|
if (!syntax) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.types[name] = this.createDescriptor(syntax, 'Type', name);
|
||
|
|
}
|
||
|
|
|
||
|
|
checkAtruleName(atruleName) {
|
||
|
|
if (!this.getAtrule(atruleName)) {
|
||
|
|
return new error.SyntaxReferenceError('Unknown at-rule', '@' + atruleName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
checkAtrulePrelude(atruleName, prelude) {
|
||
|
|
const error = this.checkAtruleName(atruleName);
|
||
|
|
|
||
|
|
if (error) {
|
||
|
|
return error;
|
||
|
|
}
|
||
|
|
|
||
|
|
const atrule = this.getAtrule(atruleName);
|
||
|
|
|
||
|
|
if (!atrule.prelude && prelude) {
|
||
|
|
return new SyntaxError('At-rule `@' + atruleName + '` should not contain a prelude');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (atrule.prelude && !prelude) {
|
||
|
|
if (!matchSyntax(this, atrule.prelude, '', false).matched) {
|
||
|
|
return new SyntaxError('At-rule `@' + atruleName + '` should contain a prelude');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
checkAtruleDescriptorName(atruleName, descriptorName) {
|
||
|
|
const error$1 = this.checkAtruleName(atruleName);
|
||
|
|
|
||
|
|
if (error$1) {
|
||
|
|
return error$1;
|
||
|
|
}
|
||
|
|
|
||
|
|
const atrule = this.getAtrule(atruleName);
|
||
|
|
const descriptor = names.keyword(descriptorName);
|
||
|
|
|
||
|
|
if (!atrule.descriptors) {
|
||
|
|
return new SyntaxError('At-rule `@' + atruleName + '` has no known descriptors');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!atrule.descriptors[descriptor.name] &&
|
||
|
|
!atrule.descriptors[descriptor.basename]) {
|
||
|
|
return new error.SyntaxReferenceError('Unknown at-rule descriptor', descriptorName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
checkPropertyName(propertyName) {
|
||
|
|
if (!this.getProperty(propertyName)) {
|
||
|
|
return new error.SyntaxReferenceError('Unknown property', propertyName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
matchAtrulePrelude(atruleName, prelude) {
|
||
|
|
const error = this.checkAtrulePrelude(atruleName, prelude);
|
||
|
|
|
||
|
|
if (error) {
|
||
|
|
return buildMatchResult(null, error);
|
||
|
|
}
|
||
|
|
|
||
|
|
const atrule = this.getAtrule(atruleName);
|
||
|
|
|
||
|
|
if (!atrule.prelude) {
|
||
|
|
return buildMatchResult(null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
return matchSyntax(this, atrule.prelude, prelude || '', false);
|
||
|
|
}
|
||
|
|
matchAtruleDescriptor(atruleName, descriptorName, value) {
|
||
|
|
const error = this.checkAtruleDescriptorName(atruleName, descriptorName);
|
||
|
|
|
||
|
|
if (error) {
|
||
|
|
return buildMatchResult(null, error);
|
||
|
|
}
|
||
|
|
|
||
|
|
const atrule = this.getAtrule(atruleName);
|
||
|
|
const descriptor = names.keyword(descriptorName);
|
||
|
|
|
||
|
|
return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false);
|
||
|
|
}
|
||
|
|
matchDeclaration(node) {
|
||
|
|
if (node.type !== 'Declaration') {
|
||
|
|
return buildMatchResult(null, new Error('Not a Declaration node'));
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.matchProperty(node.property, node.value);
|
||
|
|
}
|
||
|
|
matchProperty(propertyName, value) {
|
||
|
|
// don't match syntax for a custom property at the moment
|
||
|
|
if (names.property(propertyName).custom) {
|
||
|
|
return buildMatchResult(null, new Error('Lexer matching doesn\'t applicable for custom properties'));
|
||
|
|
}
|
||
|
|
|
||
|
|
const error = this.checkPropertyName(propertyName);
|
||
|
|
|
||
|
|
if (error) {
|
||
|
|
return buildMatchResult(null, error);
|
||
|
|
}
|
||
|
|
|
||
|
|
return matchSyntax(this, this.getProperty(propertyName), value, true);
|
||
|
|
}
|
||
|
|
matchType(typeName, value) {
|
||
|
|
const typeSyntax = this.getType(typeName);
|
||
|
|
|
||
|
|
if (!typeSyntax) {
|
||
|
|
return buildMatchResult(null, new error.SyntaxReferenceError('Unknown type', typeName));
|
||
|
|
}
|
||
|
|
|
||
|
|
return matchSyntax(this, typeSyntax, value, false);
|
||
|
|
}
|
||
|
|
match(syntax, value) {
|
||
|
|
if (typeof syntax !== 'string' && (!syntax || !syntax.type)) {
|
||
|
|
return buildMatchResult(null, new error.SyntaxReferenceError('Bad syntax'));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof syntax === 'string' || !syntax.match) {
|
||
|
|
syntax = this.createDescriptor(syntax, 'Type', 'anonymous');
|
||
|
|
}
|
||
|
|
|
||
|
|
return matchSyntax(this, syntax, value, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
findValueFragments(propertyName, value, type, name) {
|
||
|
|
return search.matchFragments(this, value, this.matchProperty(propertyName, value), type, name);
|
||
|
|
}
|
||
|
|
findDeclarationValueFragments(declaration, type, name) {
|
||
|
|
return search.matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);
|
||
|
|
}
|
||
|
|
findAllFragments(ast, type, name) {
|
||
|
|
const result = [];
|
||
|
|
|
||
|
|
this.syntax.walk(ast, {
|
||
|
|
visit: 'Declaration',
|
||
|
|
enter: (declaration) => {
|
||
|
|
result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
getAtrule(atruleName, fallbackBasename = true) {
|
||
|
|
const atrule = names.keyword(atruleName);
|
||
|
|
const atruleEntry = atrule.vendor && fallbackBasename
|
||
|
|
? this.atrules[atrule.name] || this.atrules[atrule.basename]
|
||
|
|
: this.atrules[atrule.name];
|
||
|
|
|
||
|
|
return atruleEntry || null;
|
||
|
|
}
|
||
|
|
getAtrulePrelude(atruleName, fallbackBasename = true) {
|
||
|
|
const atrule = this.getAtrule(atruleName, fallbackBasename);
|
||
|
|
|
||
|
|
return atrule && atrule.prelude || null;
|
||
|
|
}
|
||
|
|
getAtruleDescriptor(atruleName, name) {
|
||
|
|
return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators
|
||
|
|
? this.atrules[atruleName].declarators[name] || null
|
||
|
|
: null;
|
||
|
|
}
|
||
|
|
getProperty(propertyName, fallbackBasename = true) {
|
||
|
|
const property = names.property(propertyName);
|
||
|
|
const propertyEntry = property.vendor && fallbackBasename
|
||
|
|
? this.properties[property.name] || this.properties[property.basename]
|
||
|
|
: this.properties[property.name];
|
||
|
|
|
||
|
|
return propertyEntry || null;
|
||
|
|
}
|
||
|
|
getType(name) {
|
||
|
|
return hasOwnProperty.call(this.types, name) ? this.types[name] : null;
|
||
|
|
}
|
||
|
|
|
||
|
|
validate() {
|
||
|
|
function validate(syntax, name, broken, descriptor) {
|
||
|
|
if (broken.has(name)) {
|
||
|
|
return broken.get(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
broken.set(name, false);
|
||
|
|
if (descriptor.syntax !== null) {
|
||
|
|
walk.walk(descriptor.syntax, function(node) {
|
||
|
|
if (node.type !== 'Type' && node.type !== 'Property') {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const map = node.type === 'Type' ? syntax.types : syntax.properties;
|
||
|
|
const brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;
|
||
|
|
|
||
|
|
if (!hasOwnProperty.call(map, node.name) || validate(syntax, node.name, brokenMap, map[node.name])) {
|
||
|
|
broken.set(name, true);
|
||
|
|
}
|
||
|
|
}, this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let brokenTypes = new Map();
|
||
|
|
let brokenProperties = new Map();
|
||
|
|
|
||
|
|
for (const key in this.types) {
|
||
|
|
validate(this, key, brokenTypes, this.types[key]);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const key in this.properties) {
|
||
|
|
validate(this, key, brokenProperties, this.properties[key]);
|
||
|
|
}
|
||
|
|
|
||
|
|
brokenTypes = [...brokenTypes.keys()].filter(name => brokenTypes.get(name));
|
||
|
|
brokenProperties = [...brokenProperties.keys()].filter(name => brokenProperties.get(name));
|
||
|
|
|
||
|
|
if (brokenTypes.length || brokenProperties.length) {
|
||
|
|
return {
|
||
|
|
types: brokenTypes,
|
||
|
|
properties: brokenProperties
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
dump(syntaxAsAst, pretty) {
|
||
|
|
return {
|
||
|
|
generic: this.generic,
|
||
|
|
units: this.units,
|
||
|
|
types: dumpMapSyntax(this.types, !pretty, syntaxAsAst),
|
||
|
|
properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst),
|
||
|
|
atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
toString() {
|
||
|
|
return JSON.stringify(this.dump());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
exports.Lexer = Lexer;
|