'use strict';
|
|
var isObject = require('isobject');
|
var define = require('define-property');
|
var utils = require('snapdragon-util');
|
var ownNames;
|
|
/**
|
* Create a new AST `Node` with the given `val` and `type`.
|
*
|
* ```js
|
* var node = new Node('*', 'Star');
|
* var node = new Node({type: 'star', val: '*'});
|
* ```
|
* @name Node
|
* @param {String|Object} `val` Pass a matched substring, or an object to merge onto the node.
|
* @param {String} `type` The node type to use when `val` is a string.
|
* @return {Object} node instance
|
* @api public
|
*/
|
|
function Node(val, type, parent) {
|
if (typeof type !== 'string') {
|
parent = type;
|
type = null;
|
}
|
|
define(this, 'parent', parent);
|
define(this, 'isNode', true);
|
define(this, 'expect', null);
|
|
if (typeof type !== 'string' && isObject(val)) {
|
lazyKeys();
|
var keys = Object.keys(val);
|
for (var i = 0; i < keys.length; i++) {
|
var key = keys[i];
|
if (ownNames.indexOf(key) === -1) {
|
this[key] = val[key];
|
}
|
}
|
} else {
|
this.type = type;
|
this.val = val;
|
}
|
}
|
|
/**
|
* Returns true if the given value is a node.
|
*
|
* ```js
|
* var Node = require('snapdragon-node');
|
* var node = new Node({type: 'foo'});
|
* console.log(Node.isNode(node)); //=> true
|
* console.log(Node.isNode({})); //=> false
|
* ```
|
* @param {Object} `node`
|
* @returns {Boolean}
|
* @api public
|
*/
|
|
Node.isNode = function(node) {
|
return utils.isNode(node);
|
};
|
|
/**
|
* Define a non-enumberable property on the node instance.
|
* Useful for adding properties that shouldn't be extended
|
* or visible during debugging.
|
*
|
* ```js
|
* var node = new Node();
|
* node.define('foo', 'something non-enumerable');
|
* ```
|
* @param {String} `name`
|
* @param {any} `val`
|
* @return {Object} returns the node instance
|
* @api public
|
*/
|
|
Node.prototype.define = function(name, val) {
|
define(this, name, val);
|
return this;
|
};
|
|
/**
|
* 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'});
|
* node.isEmpty(); //=> true
|
* node.val = 'foo';
|
* node.isEmpty(); //=> false
|
* ```
|
* @param {Function} `fn` (optional) Filter function that is called on `node` and/or child nodes. `isEmpty` will return false immediately when the filter function returns false on any nodes.
|
* @return {Boolean}
|
* @api public
|
*/
|
|
Node.prototype.isEmpty = function(fn) {
|
return utils.isEmpty(this, fn);
|
};
|
|
/**
|
* Given node `foo` and node `bar`, push node `bar` onto `foo.nodes`, and
|
* set `foo` as `bar.parent`.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* foo.push(bar);
|
* ```
|
* @param {Object} `node`
|
* @return {Number} Returns the length of `node.nodes`
|
* @api public
|
*/
|
|
Node.prototype.push = function(node) {
|
assert(Node.isNode(node), 'expected node to be an instance of Node');
|
define(node, 'parent', this);
|
|
this.nodes = this.nodes || [];
|
return this.nodes.push(node);
|
};
|
|
/**
|
* Given node `foo` and node `bar`, unshift node `bar` onto `foo.nodes`, and
|
* set `foo` as `bar.parent`.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* foo.unshift(bar);
|
* ```
|
* @param {Object} `node`
|
* @return {Number} Returns the length of `node.nodes`
|
* @api public
|
*/
|
|
Node.prototype.unshift = function(node) {
|
assert(Node.isNode(node), 'expected node to be an instance of Node');
|
define(node, 'parent', this);
|
|
this.nodes = this.nodes || [];
|
return this.nodes.unshift(node);
|
};
|
|
/**
|
* Pop a node from `node.nodes`.
|
*
|
* ```js
|
* var node = new Node({type: 'foo'});
|
* node.push(new Node({type: 'a'}));
|
* node.push(new Node({type: 'b'}));
|
* node.push(new Node({type: 'c'}));
|
* node.push(new Node({type: 'd'}));
|
* console.log(node.nodes.length);
|
* //=> 4
|
* node.pop();
|
* console.log(node.nodes.length);
|
* //=> 3
|
* ```
|
* @return {Number} Returns the popped `node`
|
* @api public
|
*/
|
|
Node.prototype.pop = function() {
|
return this.nodes && this.nodes.pop();
|
};
|
|
/**
|
* Shift a node from `node.nodes`.
|
*
|
* ```js
|
* var node = new Node({type: 'foo'});
|
* node.push(new Node({type: 'a'}));
|
* node.push(new Node({type: 'b'}));
|
* node.push(new Node({type: 'c'}));
|
* node.push(new Node({type: 'd'}));
|
* console.log(node.nodes.length);
|
* //=> 4
|
* node.shift();
|
* console.log(node.nodes.length);
|
* //=> 3
|
* ```
|
* @return {Object} Returns the shifted `node`
|
* @api public
|
*/
|
|
Node.prototype.shift = function() {
|
return this.nodes && this.nodes.shift();
|
};
|
|
/**
|
* Remove `node` from `node.nodes`.
|
*
|
* ```js
|
* node.remove(childNode);
|
* ```
|
* @param {Object} `node`
|
* @return {Object} Returns the removed node.
|
* @api public
|
*/
|
|
Node.prototype.remove = function(node) {
|
assert(Node.isNode(node), 'expected node to be an instance of Node');
|
this.nodes = this.nodes || [];
|
var idx = node.index;
|
if (idx !== -1) {
|
node.index = -1;
|
return this.nodes.splice(idx, 1);
|
}
|
return null;
|
};
|
|
/**
|
* Get the first child node from `node.nodes` that matches the given `type`.
|
* If `type` is a number, the child node at that index is returned.
|
*
|
* ```js
|
* var child = node.find(1); //<= index of the node to get
|
* var child = node.find('foo'); //<= node.type of a child node
|
* var child = node.find(/^(foo|bar)$/); //<= regex to match node.type
|
* var child = node.find(['foo', 'bar']); //<= array of node.type(s)
|
* ```
|
* @param {String} `type`
|
* @return {Object} Returns a child node or undefined.
|
* @api public
|
*/
|
|
Node.prototype.find = function(type) {
|
return utils.findNode(this.nodes, type);
|
};
|
|
/**
|
* Return true if the node is the given `type`.
|
*
|
* ```js
|
* var node = new Node({type: 'bar'});
|
* cosole.log(node.isType('foo')); // false
|
* cosole.log(node.isType(/^(foo|bar)$/)); // true
|
* cosole.log(node.isType(['foo', 'bar'])); // true
|
* ```
|
* @param {String} `type`
|
* @return {Boolean}
|
* @api public
|
*/
|
|
Node.prototype.isType = function(type) {
|
return utils.isType(this, type);
|
};
|
|
/**
|
* Return true if the `node.nodes` has the given `type`.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* foo.push(bar);
|
*
|
* cosole.log(foo.hasType('qux')); // false
|
* cosole.log(foo.hasType(/^(qux|bar)$/)); // true
|
* cosole.log(foo.hasType(['qux', 'bar'])); // true
|
* ```
|
* @param {String} `type`
|
* @return {Boolean}
|
* @api public
|
*/
|
|
Node.prototype.hasType = function(type) {
|
return utils.hasType(this, type);
|
};
|
|
/**
|
* Get the siblings array, or `null` if it doesn't exist.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* var baz = new Node({type: 'baz'});
|
* foo.push(bar);
|
* foo.push(baz);
|
*
|
* console.log(bar.siblings.length) // 2
|
* console.log(baz.siblings.length) // 2
|
* ```
|
* @return {Array}
|
* @api public
|
*/
|
|
Object.defineProperty(Node.prototype, 'siblings', {
|
set: function() {
|
throw new Error('node.siblings is a getter and cannot be defined');
|
},
|
get: function() {
|
return this.parent ? this.parent.nodes : null;
|
}
|
});
|
|
/**
|
* Get the node's current index from `node.parent.nodes`.
|
* This should always be correct, even when the parent adds nodes.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* var baz = new Node({type: 'baz'});
|
* var qux = new Node({type: 'qux'});
|
* foo.push(bar);
|
* foo.push(baz);
|
* foo.unshift(qux);
|
*
|
* console.log(bar.index) // 1
|
* console.log(baz.index) // 2
|
* console.log(qux.index) // 0
|
* ```
|
* @return {Number}
|
* @api public
|
*/
|
|
Object.defineProperty(Node.prototype, 'index', {
|
set: function(index) {
|
define(this, 'idx', index);
|
},
|
get: function() {
|
if (!Array.isArray(this.siblings)) {
|
return -1;
|
}
|
var tok = this.idx !== -1 ? this.siblings[this.idx] : null;
|
if (tok !== this) {
|
this.idx = this.siblings.indexOf(this);
|
}
|
return this.idx;
|
}
|
});
|
|
/**
|
* Get the previous node from the siblings array or `null`.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* var baz = new Node({type: 'baz'});
|
* foo.push(bar);
|
* foo.push(baz);
|
*
|
* console.log(baz.prev.type) // 'bar'
|
* ```
|
* @return {Object}
|
* @api public
|
*/
|
|
Object.defineProperty(Node.prototype, 'prev', {
|
set: function() {
|
throw new Error('node.prev is a getter and cannot be defined');
|
},
|
get: function() {
|
if (Array.isArray(this.siblings)) {
|
return this.siblings[this.index - 1] || this.parent.prev;
|
}
|
return null;
|
}
|
});
|
|
/**
|
* Get the siblings array, or `null` if it doesn't exist.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* var baz = new Node({type: 'baz'});
|
* foo.push(bar);
|
* foo.push(baz);
|
*
|
* console.log(bar.siblings.length) // 2
|
* console.log(baz.siblings.length) // 2
|
* ```
|
* @return {Object}
|
* @api public
|
*/
|
|
Object.defineProperty(Node.prototype, 'next', {
|
set: function() {
|
throw new Error('node.next is a getter and cannot be defined');
|
},
|
get: function() {
|
if (Array.isArray(this.siblings)) {
|
return this.siblings[this.index + 1] || this.parent.next;
|
}
|
return null;
|
}
|
});
|
|
/**
|
* Get the first node from `node.nodes`.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* var baz = new Node({type: 'baz'});
|
* var qux = new Node({type: 'qux'});
|
* foo.push(bar);
|
* foo.push(baz);
|
* foo.push(qux);
|
*
|
* console.log(foo.first.type) // 'bar'
|
* ```
|
* @return {Object} The first node, or undefiend
|
* @api public
|
*/
|
|
Object.defineProperty(Node.prototype, 'first', {
|
get: function() {
|
return this.nodes ? this.nodes[0] : null;
|
}
|
});
|
|
/**
|
* Get the last node from `node.nodes`.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* var baz = new Node({type: 'baz'});
|
* var qux = new Node({type: 'qux'});
|
* foo.push(bar);
|
* foo.push(baz);
|
* foo.push(qux);
|
*
|
* console.log(foo.last.type) // 'qux'
|
* ```
|
* @return {Object} The last node, or undefiend
|
* @api public
|
*/
|
|
Object.defineProperty(Node.prototype, 'last', {
|
get: function() {
|
return this.nodes ? utils.last(this.nodes) : null;
|
}
|
});
|
|
/**
|
* Get the last node from `node.nodes`.
|
*
|
* ```js
|
* var foo = new Node({type: 'foo'});
|
* var bar = new Node({type: 'bar'});
|
* var baz = new Node({type: 'baz'});
|
* var qux = new Node({type: 'qux'});
|
* foo.push(bar);
|
* foo.push(baz);
|
* foo.push(qux);
|
*
|
* console.log(foo.last.type) // 'qux'
|
* ```
|
* @return {Object} The last node, or undefiend
|
* @api public
|
*/
|
|
Object.defineProperty(Node.prototype, 'scope', {
|
get: function() {
|
if (this.isScope !== true) {
|
return this.parent ? this.parent.scope : this;
|
}
|
return this;
|
}
|
});
|
|
/**
|
* Get own property names from Node prototype, but only the
|
* first time `Node` is instantiated
|
*/
|
|
function lazyKeys() {
|
if (!ownNames) {
|
ownNames = Object.getOwnPropertyNames(Node.prototype);
|
}
|
}
|
|
/**
|
* Simplified assertion. Throws an error is `val` is falsey.
|
*/
|
|
function assert(val, message) {
|
if (!val) throw new Error(message);
|
}
|
|
/**
|
* Expose `Node`
|
*/
|
|
exports = module.exports = Node;
|
