121 lines
3.4 KiB
JavaScript
121 lines
3.4 KiB
JavaScript
'use strict';
|
|
|
|
const dataPatch = require('./data-patch.cjs');
|
|
|
|
const mdnAtrules = require('mdn-data/css/at-rules.json');
|
|
const mdnProperties = require('mdn-data/css/properties.json');
|
|
const mdnSyntaxes = require('mdn-data/css/syntaxes.json');
|
|
|
|
const hasOwn = Object.hasOwn || ((object, property) => Object.prototype.hasOwnProperty.call(object, property));
|
|
const extendSyntax = /^\s*\|\s*/;
|
|
|
|
function preprocessAtrules(dict) {
|
|
const result = Object.create(null);
|
|
|
|
for (const [atruleName, atrule] of Object.entries(dict)) {
|
|
let descriptors = null;
|
|
|
|
if (atrule.descriptors) {
|
|
descriptors = Object.create(null);
|
|
|
|
for (const [name, descriptor] of Object.entries(atrule.descriptors)) {
|
|
descriptors[name] = descriptor.syntax;
|
|
}
|
|
}
|
|
|
|
result[atruleName.substr(1)] = {
|
|
prelude: atrule.syntax.trim().replace(/\{(.|\s)+\}/, '').match(/^@\S+\s+([^;\{]*)/)[1].trim() || null,
|
|
descriptors
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function patchDictionary(dict, patchDict) {
|
|
const result = Object.create(null);
|
|
|
|
// copy all syntaxes for an original dict
|
|
for (const [key, value] of Object.entries(dict)) {
|
|
if (value) {
|
|
result[key] = value.syntax || value;
|
|
}
|
|
}
|
|
|
|
// apply a patch
|
|
for (const key of Object.keys(patchDict)) {
|
|
if (hasOwn(dict, key)) {
|
|
if (patchDict[key].syntax) {
|
|
result[key] = extendSyntax.test(patchDict[key].syntax)
|
|
? result[key] + ' ' + patchDict[key].syntax.trim()
|
|
: patchDict[key].syntax;
|
|
} else {
|
|
delete result[key];
|
|
}
|
|
} else {
|
|
if (patchDict[key].syntax) {
|
|
result[key] = patchDict[key].syntax.replace(extendSyntax, '');
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function preprocessPatchAtrulesDescritors(declarations) {
|
|
const result = {};
|
|
|
|
for (const [key, value] of Object.entries(declarations || {})) {
|
|
result[key] = typeof value === 'string'
|
|
? { syntax: value }
|
|
: value;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function patchAtrules(dict, patchDict) {
|
|
const result = {};
|
|
|
|
// copy all syntaxes for an original dict
|
|
for (const key in dict) {
|
|
if (patchDict[key] === null) {
|
|
continue;
|
|
}
|
|
|
|
const atrulePatch = patchDict[key] || {};
|
|
|
|
result[key] = {
|
|
prelude: key in patchDict && 'prelude' in atrulePatch
|
|
? atrulePatch.prelude
|
|
: dict[key].prelude || null,
|
|
descriptors: patchDictionary(
|
|
dict[key].descriptors || {},
|
|
preprocessPatchAtrulesDescritors(atrulePatch.descriptors)
|
|
)
|
|
};
|
|
}
|
|
|
|
// apply a patch
|
|
for (const [key, atrulePatch] of Object.entries(patchDict)) {
|
|
if (atrulePatch && !hasOwn(dict, key)) {
|
|
result[key] = {
|
|
prelude: atrulePatch.prelude || null,
|
|
descriptors: atrulePatch.descriptors
|
|
? patchDictionary({}, preprocessPatchAtrulesDescritors(atrulePatch.descriptors))
|
|
: null
|
|
};
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
const definitions = {
|
|
types: patchDictionary(mdnSyntaxes, dataPatch.types),
|
|
atrules: patchAtrules(preprocessAtrules(mdnAtrules), dataPatch.atrules),
|
|
properties: patchDictionary(mdnProperties, dataPatch.properties)
|
|
};
|
|
|
|
module.exports = definitions;
|