shift73k/assets_old/node_modules/css-tree/lib/walker/create.js

262 lines
6.9 KiB
JavaScript

var hasOwnProperty = Object.prototype.hasOwnProperty;
var noop = function() {};
function ensureFunction(value) {
return typeof value === 'function' ? value : noop;
}
function invokeForType(fn, type) {
return function(node, item, list) {
if (node.type === type) {
fn.call(this, node, item, list);
}
};
}
function getWalkersFromStructure(name, nodeType) {
var structure = nodeType.structure;
var walkers = [];
for (var key in structure) {
if (hasOwnProperty.call(structure, key) === false) {
continue;
}
var fieldTypes = structure[key];
var walker = {
name: key,
type: false,
nullable: false
};
if (!Array.isArray(structure[key])) {
fieldTypes = [structure[key]];
}
for (var i = 0; i < fieldTypes.length; i++) {
var fieldType = fieldTypes[i];
if (fieldType === null) {
walker.nullable = true;
} else if (typeof fieldType === 'string') {
walker.type = 'node';
} else if (Array.isArray(fieldType)) {
walker.type = 'list';
}
}
if (walker.type) {
walkers.push(walker);
}
}
if (walkers.length) {
return {
context: nodeType.walkContext,
fields: walkers
};
}
return null;
}
function getTypesFromConfig(config) {
var types = {};
for (var name in config.node) {
if (hasOwnProperty.call(config.node, name)) {
var nodeType = config.node[name];
if (!nodeType.structure) {
throw new Error('Missed `structure` field in `' + name + '` node type definition');
}
types[name] = getWalkersFromStructure(name, nodeType);
}
}
return types;
}
function createTypeIterator(config, reverse) {
var fields = config.fields.slice();
var contextName = config.context;
var useContext = typeof contextName === 'string';
if (reverse) {
fields.reverse();
}
return function(node, context, walk) {
var prevContextValue;
if (useContext) {
prevContextValue = context[contextName];
context[contextName] = node;
}
for (var i = 0; i < fields.length; i++) {
var field = fields[i];
var ref = node[field.name];
if (!field.nullable || ref) {
if (field.type === 'list') {
if (reverse) {
ref.forEachRight(walk);
} else {
ref.forEach(walk);
}
} else {
walk(ref);
}
}
}
if (useContext) {
context[contextName] = prevContextValue;
}
};
}
function createFastTraveralMap(iterators) {
return {
Atrule: {
StyleSheet: iterators.StyleSheet,
Atrule: iterators.Atrule,
Rule: iterators.Rule,
Block: iterators.Block
},
Rule: {
StyleSheet: iterators.StyleSheet,
Atrule: iterators.Atrule,
Rule: iterators.Rule,
Block: iterators.Block
},
Declaration: {
StyleSheet: iterators.StyleSheet,
Atrule: iterators.Atrule,
Rule: iterators.Rule,
Block: iterators.Block
}
};
}
module.exports = function createWalker(config) {
var types = getTypesFromConfig(config);
var iteratorsNatural = {};
var iteratorsReverse = {};
for (var name in types) {
if (hasOwnProperty.call(types, name) && types[name] !== null) {
iteratorsNatural[name] = createTypeIterator(types[name], false);
iteratorsReverse[name] = createTypeIterator(types[name], true);
}
}
var fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);
var fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);
var walk = function(root, options) {
function walkNode(node, item, list) {
enter.call(context, node, item, list);
if (iterators.hasOwnProperty(node.type)) {
iterators[node.type](node, context, walkNode);
}
leave.call(context, node, item, list);
}
var enter = noop;
var leave = noop;
var iterators = iteratorsNatural;
var context = {
root: root,
stylesheet: null,
atrule: null,
atrulePrelude: null,
rule: null,
selector: null,
block: null,
declaration: null,
function: null
};
if (typeof options === 'function') {
enter = options;
} else if (options) {
enter = ensureFunction(options.enter);
leave = ensureFunction(options.leave);
if (options.reverse) {
iterators = iteratorsReverse;
}
if (options.visit) {
if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {
iterators = options.reverse
? fastTraversalIteratorsReverse[options.visit]
: fastTraversalIteratorsNatural[options.visit];
} else if (!types.hasOwnProperty(options.visit)) {
throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).join(', ') + ')');
}
enter = invokeForType(enter, options.visit);
leave = invokeForType(leave, options.visit);
}
}
if (enter === noop && leave === noop) {
throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
}
// swap handlers in reverse mode to invert visit order
if (options.reverse) {
var tmp = enter;
enter = leave;
leave = tmp;
}
walkNode(root);
};
walk.find = function(ast, fn) {
var found = null;
walk(ast, function(node, item, list) {
if (found === null && fn.call(this, node, item, list)) {
found = node;
}
});
return found;
};
walk.findLast = function(ast, fn) {
var found = null;
walk(ast, {
reverse: true,
enter: function(node, item, list) {
if (found === null && fn.call(this, node, item, list)) {
found = node;
}
}
});
return found;
};
walk.findAll = function(ast, fn) {
var found = [];
walk(ast, function(node, item, list) {
if (fn.call(this, node, item, list)) {
found.push(node);
}
});
return found;
};
return walk;
};