'use strict';
|
|
var typeOf = require('kind-of');
|
var utils = module.exports;
|
|
/**
|
* Returns true if the given value is a node.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var node = new Node({type: 'foo'});
|
* console.log(utils.isNode(node)); //=> true
|
* console.log(utils.isNode({})); //=> false
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @returns {Boolean}
|
* @api public
|
*/
|
|
utils.isNode = function(node) {
|
return typeOf(node) === 'object' && node.isNode === true;
|
};
|
|
/**
|
* Emit an empty string for the given `node`.
|
*
|
* ```js
|
* // do nothing for beginning-of-string
|
* snapdragon.compiler.set('bos', utils.noop);
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @returns {undefined}
|
* @api public
|
*/
|
|
utils.noop = function(node) {
|
append(this, '', node);
|
};
|
|
/**
|
* Appdend `node.val` to `compiler.output`, exactly as it was created
|
* by the parser.
|
*
|
* ```js
|
* snapdragon.compiler.set('text', utils.identity);
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @returns {undefined}
|
* @api public
|
*/
|
|
utils.identity = function(node) {
|
append(this, node.val, node);
|
};
|
|
/**
|
* Previously named `.emit`, this method appends the given `val`
|
* to `compiler.output` for the given node. Useful when you know
|
* what value should be appended advance, regardless of the actual
|
* value of `node.val`.
|
*
|
* ```js
|
* snapdragon.compiler
|
* .set('i', function(node) {
|
* this.mapVisit(node);
|
* })
|
* .set('i.open', utils.append('<i>'))
|
* .set('i.close', utils.append('</i>'))
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @returns {Function} Returns a compiler middleware function.
|
* @api public
|
*/
|
|
utils.append = function(val) {
|
return function(node) {
|
append(this, val, node);
|
};
|
};
|
|
/**
|
* Used in compiler middleware, this onverts an AST node into
|
* an empty `text` node and deletes `node.nodes` if it exists.
|
* The advantage of this method is that, as opposed to completely
|
* removing the node, indices will not need to be re-calculated
|
* in sibling nodes, and nothing is appended to the output.
|
*
|
* ```js
|
* utils.toNoop(node);
|
* // convert `node.nodes` to the given value instead of deleting it
|
* utils.toNoop(node, []);
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {Array} `nodes` Optionally pass a new `nodes` value, to replace the existing `node.nodes` array.
|
* @api public
|
*/
|
|
utils.toNoop = function(node, nodes) {
|
if (nodes) {
|
node.nodes = nodes;
|
} else {
|
delete node.nodes;
|
node.type = 'text';
|
node.val = '';
|
}
|
};
|
|
/**
|
* Visit `node` with the given `fn`. The built-in `.visit` method in snapdragon
|
* automatically calls registered compilers, this allows you to pass a visitor
|
* function.
|
*
|
* ```js
|
* snapdragon.compiler.set('i', function(node) {
|
* utils.visit(node, function(childNode) {
|
* // do stuff with "childNode"
|
* return childNode;
|
* });
|
* });
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {Function} `fn`
|
* @return {Object} returns the node after recursively visiting all child nodes.
|
* @api public
|
*/
|
|
utils.visit = function(node, fn) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isFunction(fn), 'expected a visitor function');
|
fn(node);
|
return node.nodes ? utils.mapVisit(node, fn) : node;
|
};
|
|
/**
|
* Map [visit](#visit) the given `fn` over `node.nodes`. This is called by
|
* [visit](#visit), use this method if you do not want `fn` to be called on
|
* the first node.
|
*
|
* ```js
|
* snapdragon.compiler.set('i', function(node) {
|
* utils.mapVisit(node, function(childNode) {
|
* // do stuff with "childNode"
|
* return childNode;
|
* });
|
* });
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {Object} `options`
|
* @param {Function} `fn`
|
* @return {Object} returns the node
|
* @api public
|
*/
|
|
utils.mapVisit = function(node, fn) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isArray(node.nodes), 'expected node.nodes to be an array');
|
assert(isFunction(fn), 'expected a visitor function');
|
|
for (var i = 0; i < node.nodes.length; i++) {
|
utils.visit(node.nodes[i], fn);
|
}
|
return node;
|
};
|
|
/**
|
* Unshift an `*.open` node onto `node.nodes`.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* snapdragon.parser.set('brace', function(node) {
|
* var match = this.match(/^{/);
|
* if (match) {
|
* var parent = new Node({type: 'brace'});
|
* utils.addOpen(parent, Node);
|
* console.log(parent.nodes[0]):
|
* // { type: 'brace.open', val: '' };
|
*
|
* // push the parent "brace" node onto the stack
|
* this.push(parent);
|
*
|
* // return the parent node, so it's also added to the AST
|
* return brace;
|
* }
|
* });
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {Function} `Node` (required) Node constructor function from [snapdragon-node][].
|
* @param {Function} `filter` Optionaly specify a filter function to exclude the node.
|
* @return {Object} Returns the created opening node.
|
* @api public
|
*/
|
|
utils.addOpen = function(node, Node, val, filter) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isFunction(Node), 'expected Node to be a constructor function');
|
|
if (typeof val === 'function') {
|
filter = val;
|
val = '';
|
}
|
|
if (typeof filter === 'function' && !filter(node)) return;
|
var open = new Node({ type: node.type + '.open', val: val});
|
var unshift = node.unshift || node.unshiftNode;
|
if (typeof unshift === 'function') {
|
unshift.call(node, open);
|
} else {
|
utils.unshiftNode(node, open);
|
}
|
return open;
|
};
|
|
/**
|
* Push a `*.close` node onto `node.nodes`.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* snapdragon.parser.set('brace', function(node) {
|
* var match = this.match(/^}/);
|
* if (match) {
|
* var parent = this.parent();
|
* if (parent.type !== 'brace') {
|
* throw new Error('missing opening: ' + '}');
|
* }
|
*
|
* utils.addClose(parent, Node);
|
* console.log(parent.nodes[parent.nodes.length - 1]):
|
* // { type: 'brace.close', val: '' };
|
*
|
* // no need to return a node, since the parent
|
* // was already added to the AST
|
* return;
|
* }
|
* });
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {Function} `Node` (required) Node constructor function from [snapdragon-node][].
|
* @param {Function} `filter` Optionaly specify a filter function to exclude the node.
|
* @return {Object} Returns the created closing node.
|
* @api public
|
*/
|
|
utils.addClose = function(node, Node, val, filter) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isFunction(Node), 'expected Node to be a constructor function');
|
|
if (typeof val === 'function') {
|
filter = val;
|
val = '';
|
}
|
|
if (typeof filter === 'function' && !filter(node)) return;
|
var close = new Node({ type: node.type + '.close', val: val});
|
var push = node.push || node.pushNode;
|
if (typeof push === 'function') {
|
push.call(node, close);
|
} else {
|
utils.pushNode(node, close);
|
}
|
return close;
|
};
|
|
/**
|
* Wraps the given `node` with `*.open` and `*.close` nodes.
|
*
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {Function} `Node` (required) Node constructor function from [snapdragon-node][].
|
* @param {Function} `filter` Optionaly specify a filter function to exclude the node.
|
* @return {Object} Returns the node
|
* @api public
|
*/
|
|
utils.wrapNodes = function(node, Node, filter) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isFunction(Node), 'expected Node to be a constructor function');
|
|
utils.addOpen(node, Node, filter);
|
utils.addClose(node, Node, filter);
|
return node;
|
};
|
|
/**
|
* Push the given `node` onto `parent.nodes`, and set `parent` as `node.parent.
|
*
|
* ```js
|
* var parent = new Node({type: 'foo'});
|
* var node = new Node({type: 'bar'});
|
* utils.pushNode(parent, node);
|
* console.log(parent.nodes[0].type) // 'bar'
|
* console.log(node.parent.type) // 'foo'
|
* ```
|
* @param {Object} `parent`
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Object} Returns the child node
|
* @api public
|
*/
|
|
utils.pushNode = function(parent, node) {
|
assert(utils.isNode(parent), 'expected parent node to be an instance of Node');
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
|
node.define('parent', parent);
|
parent.nodes = parent.nodes || [];
|
parent.nodes.push(node);
|
return node;
|
};
|
|
/**
|
* Unshift `node` onto `parent.nodes`, and set `parent` as `node.parent.
|
*
|
* ```js
|
* var parent = new Node({type: 'foo'});
|
* var node = new Node({type: 'bar'});
|
* utils.unshiftNode(parent, node);
|
* console.log(parent.nodes[0].type) // 'bar'
|
* console.log(node.parent.type) // 'foo'
|
* ```
|
* @param {Object} `parent`
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {undefined}
|
* @api public
|
*/
|
|
utils.unshiftNode = function(parent, node) {
|
assert(utils.isNode(parent), 'expected parent node to be an instance of Node');
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
|
node.define('parent', parent);
|
parent.nodes = parent.nodes || [];
|
parent.nodes.unshift(node);
|
};
|
|
/**
|
* Pop the last `node` off of `parent.nodes`. The advantage of
|
* using this method is that it checks for `node.nodes` and works
|
* with any version of `snapdragon-node`.
|
*
|
* ```js
|
* var parent = new Node({type: 'foo'});
|
* utils.pushNode(parent, new Node({type: 'foo'}));
|
* utils.pushNode(parent, new Node({type: 'bar'}));
|
* utils.pushNode(parent, new Node({type: 'baz'}));
|
* console.log(parent.nodes.length); //=> 3
|
* utils.popNode(parent);
|
* console.log(parent.nodes.length); //=> 2
|
* ```
|
* @param {Object} `parent`
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Number|Undefined} Returns the length of `node.nodes` or undefined.
|
* @api public
|
*/
|
|
utils.popNode = function(node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
if (typeof node.pop === 'function') {
|
return node.pop();
|
}
|
return node.nodes && node.nodes.pop();
|
};
|
|
/**
|
* Shift the first `node` off of `parent.nodes`. The advantage of
|
* using this method is that it checks for `node.nodes` and works
|
* with any version of `snapdragon-node`.
|
*
|
* ```js
|
* var parent = new Node({type: 'foo'});
|
* utils.pushNode(parent, new Node({type: 'foo'}));
|
* utils.pushNode(parent, new Node({type: 'bar'}));
|
* utils.pushNode(parent, new Node({type: 'baz'}));
|
* console.log(parent.nodes.length); //=> 3
|
* utils.shiftNode(parent);
|
* console.log(parent.nodes.length); //=> 2
|
* ```
|
* @param {Object} `parent`
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Number|Undefined} Returns the length of `node.nodes` or undefined.
|
* @api public
|
*/
|
|
utils.shiftNode = function(node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
if (typeof node.shift === 'function') {
|
return node.shift();
|
}
|
return node.nodes && node.nodes.shift();
|
};
|
|
/**
|
* Remove the specified `node` from `parent.nodes`.
|
*
|
* ```js
|
* var parent = new Node({type: 'abc'});
|
* var foo = new Node({type: 'foo'});
|
* utils.pushNode(parent, foo);
|
* utils.pushNode(parent, new Node({type: 'bar'}));
|
* utils.pushNode(parent, new Node({type: 'baz'}));
|
* console.log(parent.nodes.length); //=> 3
|
* utils.removeNode(parent, foo);
|
* console.log(parent.nodes.length); //=> 2
|
* ```
|
* @param {Object} `parent`
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Object|undefined} Returns the removed node, if successful, or undefined if it does not exist on `parent.nodes`.
|
* @api public
|
*/
|
|
utils.removeNode = function(parent, node) {
|
assert(utils.isNode(parent), 'expected parent.node to be an instance of Node');
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
|
if (!parent.nodes) {
|
return null;
|
}
|
|
if (typeof parent.remove === 'function') {
|
return parent.remove(node);
|
}
|
|
var idx = parent.nodes.indexOf(node);
|
if (idx !== -1) {
|
return parent.nodes.splice(idx, 1);
|
}
|
};
|
|
/**
|
* Returns true if `node.type` matches the given `type`. Throws a
|
* `TypeError` if `node` is not an instance of `Node`.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var node = new Node({type: 'foo'});
|
* console.log(utils.isType(node, 'foo')); // false
|
* console.log(utils.isType(node, 'bar')); // true
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {String} `type`
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.isType = function(node, type) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
switch (typeOf(type)) {
|
case 'array':
|
var types = type.slice();
|
for (var i = 0; i < types.length; i++) {
|
if (utils.isType(node, types[i])) {
|
return true;
|
}
|
}
|
return false;
|
case 'string':
|
return node.type === type;
|
case 'regexp':
|
return type.test(node.type);
|
default: {
|
throw new TypeError('expected "type" to be an array, string or regexp');
|
}
|
}
|
};
|
|
/**
|
* Returns true if the given `node` has the given `type` in `node.nodes`.
|
* Throws a `TypeError` if `node` is not an instance of `Node`.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var node = new Node({
|
* type: 'foo',
|
* nodes: [
|
* new Node({type: 'bar'}),
|
* new Node({type: 'baz'})
|
* ]
|
* });
|
* console.log(utils.hasType(node, 'xyz')); // false
|
* console.log(utils.hasType(node, 'baz')); // true
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {String} `type`
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.hasType = function(node, type) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
if (!Array.isArray(node.nodes)) return false;
|
for (var i = 0; i < node.nodes.length; i++) {
|
if (utils.isType(node.nodes[i], type)) {
|
return true;
|
}
|
}
|
return false;
|
};
|
|
/**
|
* Returns the first node from `node.nodes` of the given `type`
|
*
|
* ```js
|
* var node = new Node({
|
* type: 'foo',
|
* nodes: [
|
* new Node({type: 'text', val: 'abc'}),
|
* new Node({type: 'text', val: 'xyz'})
|
* ]
|
* });
|
*
|
* var textNode = utils.firstOfType(node.nodes, 'text');
|
* console.log(textNode.val);
|
* //=> 'abc'
|
* ```
|
* @param {Array} `nodes`
|
* @param {String} `type`
|
* @return {Object|undefined} Returns the first matching node or undefined.
|
* @api public
|
*/
|
|
utils.firstOfType = function(nodes, type) {
|
for (var i = 0; i < nodes.length; i++) {
|
var node = nodes[i];
|
if (utils.isType(node, type)) {
|
return node;
|
}
|
}
|
};
|
|
/**
|
* Returns the node at the specified index, or the first node of the
|
* given `type` from `node.nodes`.
|
*
|
* ```js
|
* var node = new Node({
|
* type: 'foo',
|
* nodes: [
|
* new Node({type: 'text', val: 'abc'}),
|
* new Node({type: 'text', val: 'xyz'})
|
* ]
|
* });
|
*
|
* var nodeOne = utils.findNode(node.nodes, 'text');
|
* console.log(nodeOne.val);
|
* //=> 'abc'
|
*
|
* var nodeTwo = utils.findNode(node.nodes, 1);
|
* console.log(nodeTwo.val);
|
* //=> 'xyz'
|
* ```
|
*
|
* @param {Array} `nodes`
|
* @param {String|Number} `type` Node type or index.
|
* @return {Object} Returns a node or undefined.
|
* @api public
|
*/
|
|
utils.findNode = function(nodes, type) {
|
if (!Array.isArray(nodes)) {
|
return null;
|
}
|
if (typeof type === 'number') {
|
return nodes[type];
|
}
|
return utils.firstOfType(nodes, type);
|
};
|
|
/**
|
* Returns true if the given node is an "*.open" node.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var brace = new Node({type: 'brace'});
|
* var open = new Node({type: 'brace.open'});
|
* var close = new Node({type: 'brace.close'});
|
*
|
* console.log(utils.isOpen(brace)); // false
|
* console.log(utils.isOpen(open)); // true
|
* console.log(utils.isOpen(close)); // false
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.isOpen = function(node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
return node.type.slice(-5) === '.open';
|
};
|
|
/**
|
* Returns true if the given node is a "*.close" node.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var brace = new Node({type: 'brace'});
|
* var open = new Node({type: 'brace.open'});
|
* var close = new Node({type: 'brace.close'});
|
*
|
* console.log(utils.isClose(brace)); // false
|
* console.log(utils.isClose(open)); // false
|
* console.log(utils.isClose(close)); // true
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.isClose = function(node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
return node.type.slice(-6) === '.close';
|
};
|
|
/**
|
* Returns true if `node.nodes` **has** an `.open` node
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var brace = new Node({
|
* type: 'brace',
|
* nodes: []
|
* });
|
*
|
* var open = new Node({type: 'brace.open'});
|
* console.log(utils.hasOpen(brace)); // false
|
*
|
* brace.pushNode(open);
|
* console.log(utils.hasOpen(brace)); // true
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.hasOpen = function(node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
var first = node.first || node.nodes ? node.nodes[0] : null;
|
if (utils.isNode(first)) {
|
return first.type === node.type + '.open';
|
}
|
return false;
|
};
|
|
/**
|
* Returns true if `node.nodes` **has** a `.close` node
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var brace = new Node({
|
* type: 'brace',
|
* nodes: []
|
* });
|
*
|
* var close = new Node({type: 'brace.close'});
|
* console.log(utils.hasClose(brace)); // false
|
*
|
* brace.pushNode(close);
|
* console.log(utils.hasClose(brace)); // true
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.hasClose = function(node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
var last = node.last || node.nodes ? node.nodes[node.nodes.length - 1] : null;
|
if (utils.isNode(last)) {
|
return last.type === node.type + '.close';
|
}
|
return false;
|
};
|
|
/**
|
* Returns true if `node.nodes` has both `.open` and `.close` nodes
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var brace = new Node({
|
* type: 'brace',
|
* nodes: []
|
* });
|
*
|
* var open = new Node({type: 'brace.open'});
|
* var close = new Node({type: 'brace.close'});
|
* console.log(utils.hasOpen(brace)); // false
|
* console.log(utils.hasClose(brace)); // false
|
*
|
* brace.pushNode(open);
|
* brace.pushNode(close);
|
* console.log(utils.hasOpen(brace)); // true
|
* console.log(utils.hasClose(brace)); // true
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.hasOpenAndClose = function(node) {
|
return utils.hasOpen(node) && utils.hasClose(node);
|
};
|
|
/**
|
* Push the given `node` onto the `state.inside` array for the
|
* given type. This array is used as a specialized "stack" for
|
* only the given `node.type`.
|
*
|
* ```js
|
* var state = { inside: {}};
|
* var node = new Node({type: 'brace'});
|
* utils.addType(state, node);
|
* console.log(state.inside);
|
* //=> { brace: [{type: 'brace'}] }
|
* ```
|
* @param {Object} `state` The `compiler.state` object or custom state object.
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Array} Returns the `state.inside` stack for the given type.
|
* @api public
|
*/
|
|
utils.addType = function(state, node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isObject(state), 'expected state to be an object');
|
|
var type = node.parent
|
? node.parent.type
|
: node.type.replace(/\.open$/, '');
|
|
if (!state.hasOwnProperty('inside')) {
|
state.inside = {};
|
}
|
if (!state.inside.hasOwnProperty(type)) {
|
state.inside[type] = [];
|
}
|
|
var arr = state.inside[type];
|
arr.push(node);
|
return arr;
|
};
|
|
/**
|
* Remove the given `node` from the `state.inside` array for the
|
* given type. This array is used as a specialized "stack" for
|
* only the given `node.type`.
|
*
|
* ```js
|
* var state = { inside: {}};
|
* var node = new Node({type: 'brace'});
|
* utils.addType(state, node);
|
* console.log(state.inside);
|
* //=> { brace: [{type: 'brace'}] }
|
* utils.removeType(state, node);
|
* //=> { brace: [] }
|
* ```
|
* @param {Object} `state` The `compiler.state` object or custom state object.
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @return {Array} Returns the `state.inside` stack for the given type.
|
* @api public
|
*/
|
|
utils.removeType = function(state, node) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isObject(state), 'expected state to be an object');
|
|
var type = node.parent
|
? node.parent.type
|
: node.type.replace(/\.close$/, '');
|
|
if (state.inside.hasOwnProperty(type)) {
|
return state.inside[type].pop();
|
}
|
};
|
|
/**
|
* Returns true if `node.val` is an empty string, or `node.nodes` does
|
* not contain any non-empty text nodes.
|
*
|
* ```js
|
* var node = new Node({type: 'text'});
|
* utils.isEmpty(node); //=> true
|
* node.val = 'foo';
|
* utils.isEmpty(node); //=> false
|
* ```
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {Function} `fn`
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.isEmpty = function(node, fn) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
|
if (!Array.isArray(node.nodes)) {
|
if (node.type !== 'text') {
|
return true;
|
}
|
if (typeof fn === 'function') {
|
return fn(node, node.parent);
|
}
|
return !utils.trim(node.val);
|
}
|
|
for (var i = 0; i < node.nodes.length; i++) {
|
var child = node.nodes[i];
|
if (utils.isOpen(child) || utils.isClose(child)) {
|
continue;
|
}
|
if (!utils.isEmpty(child, fn)) {
|
return false;
|
}
|
}
|
|
return true;
|
};
|
|
/**
|
* Returns true if the `state.inside` stack for the given type exists
|
* and has one or more nodes on it.
|
*
|
* ```js
|
* var state = { inside: {}};
|
* var node = new Node({type: 'brace'});
|
* console.log(utils.isInsideType(state, 'brace')); //=> false
|
* utils.addType(state, node);
|
* console.log(utils.isInsideType(state, 'brace')); //=> true
|
* utils.removeType(state, node);
|
* console.log(utils.isInsideType(state, 'brace')); //=> false
|
* ```
|
* @param {Object} `state`
|
* @param {String} `type`
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.isInsideType = function(state, type) {
|
assert(isObject(state), 'expected state to be an object');
|
assert(isString(type), 'expected type to be a string');
|
|
if (!state.hasOwnProperty('inside')) {
|
return false;
|
}
|
|
if (!state.inside.hasOwnProperty(type)) {
|
return false;
|
}
|
|
return state.inside[type].length > 0;
|
};
|
|
/**
|
* Returns true if `node` is either a child or grand-child of the given `type`,
|
* or `state.inside[type]` is a non-empty array.
|
*
|
* ```js
|
* var state = { inside: {}};
|
* var node = new Node({type: 'brace'});
|
* var open = new Node({type: 'brace.open'});
|
* console.log(utils.isInside(state, open, 'brace')); //=> false
|
* utils.pushNode(node, open);
|
* console.log(utils.isInside(state, open, 'brace')); //=> true
|
* ```
|
* @param {Object} `state` Either the `compiler.state` object, if it exists, or a user-supplied state object.
|
* @param {Object} `node` Instance of [snapdragon-node][]
|
* @param {String} `type` The `node.type` to check for.
|
* @return {Boolean}
|
* @api public
|
*/
|
|
utils.isInside = function(state, node, type) {
|
assert(utils.isNode(node), 'expected node to be an instance of Node');
|
assert(isObject(state), 'expected state to be an object');
|
|
if (Array.isArray(type)) {
|
for (var i = 0; i < type.length; i++) {
|
if (utils.isInside(state, node, type[i])) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
var parent = node.parent;
|
if (typeof type === 'string') {
|
return (parent && parent.type === type) || utils.isInsideType(state, type);
|
}
|
|
if (typeOf(type) === 'regexp') {
|
if (parent && parent.type && type.test(parent.type)) {
|
return true;
|
}
|
|
var keys = Object.keys(state.inside);
|
var len = keys.length;
|
var idx = -1;
|
while (++idx < len) {
|
var key = keys[idx];
|
var val = state.inside[key];
|
|
if (Array.isArray(val) && val.length !== 0 && type.test(key)) {
|
return true;
|
}
|
}
|
}
|
return false;
|
};
|
|
/**
|
* Get the last `n` element from the given `array`. Used for getting
|
* a node from `node.nodes.`
|
*
|
* @param {Array} `array`
|
* @param {Number} `n`
|
* @return {undefined}
|
* @api public
|
*/
|
|
utils.last = function(arr, n) {
|
return arr[arr.length - (n || 1)];
|
};
|
|
/**
|
* Cast the given `val` to an array.
|
*
|
* ```js
|
* console.log(utils.arrayify(''));
|
* //=> []
|
* console.log(utils.arrayify('foo'));
|
* //=> ['foo']
|
* console.log(utils.arrayify(['foo']));
|
* //=> ['foo']
|
* ```
|
* @param {any} `val`
|
* @return {Array}
|
* @api public
|
*/
|
|
utils.arrayify = function(val) {
|
if (typeof val === 'string' && val !== '') {
|
return [val];
|
}
|
if (!Array.isArray(val)) {
|
return [];
|
}
|
return val;
|
};
|
|
/**
|
* Convert the given `val` to a string by joining with `,`. Useful
|
* for creating a cheerio/CSS/DOM-style selector from a list of strings.
|
*
|
* @param {any} `val`
|
* @return {Array}
|
* @api public
|
*/
|
|
utils.stringify = function(val) {
|
return utils.arrayify(val).join(',');
|
};
|
|
/**
|
* Ensure that the given value is a string and call `.trim()` on it,
|
* or return an empty string.
|
*
|
* @param {String} `str`
|
* @return {String}
|
* @api public
|
*/
|
|
utils.trim = function(str) {
|
return typeof str === 'string' ? str.trim() : '';
|
};
|
|
/**
|
* Return true if val is an object
|
*/
|
|
function isObject(val) {
|
return typeOf(val) === 'object';
|
}
|
|
/**
|
* Return true if val is a string
|
*/
|
|
function isString(val) {
|
return typeof val === 'string';
|
}
|
|
/**
|
* Return true if val is a function
|
*/
|
|
function isFunction(val) {
|
return typeof val === 'function';
|
}
|
|
/**
|
* Return true if val is an array
|
*/
|
|
function isArray(val) {
|
return Array.isArray(val);
|
}
|
|
/**
|
* Shim to ensure the `.append` methods work with any version of snapdragon
|
*/
|
|
function append(compiler, val, node) {
|
if (typeof compiler.append !== 'function') {
|
return compiler.emit(val, node);
|
}
|
return compiler.append(val, node);
|
}
|
|
/**
|
* Simplified assertion. Throws an error is `val` is falsey.
|
*/
|
|
function assert(val, message) {
|
if (!val) throw new Error(message);
|
}
|
