snapshot of treesome.js before deletion
This commit is contained in:
ansuz
parent
8ead5ca129
commit
1beb3f5355
1 changed files with 52 additions and 92 deletions
|
|
@ -1,9 +1,10 @@
|
|||
define([], function () {
|
||||
var tree = {};
|
||||
|
||||
tree.some = function (branch, predicate) {
|
||||
// take the index of the last element in the current branch
|
||||
var last = branch.childElementCount - 1;
|
||||
// FIXME this isn't being used
|
||||
var someElement = tree.some = function (root, predicate) {
|
||||
// take the index of the last element in the current root
|
||||
var last = root.childElementCount - 1;
|
||||
|
||||
// it might be a leaf node
|
||||
if (last < 0) { return false; }
|
||||
|
|
@ -14,12 +15,12 @@ define([], function () {
|
|||
|
||||
// check the node's children (depth first)
|
||||
// if the predicate tests true, return true
|
||||
if (tree.some(branch.children[last], predicate)) {
|
||||
if (tree.some(root.children[last], predicate)) {
|
||||
return true;
|
||||
} // otherwise none of the nodes inside it matched.
|
||||
|
||||
// check the node itself
|
||||
if (predicate(branch.children[last], last)) {
|
||||
if (predicate(root.children[last], last)) {
|
||||
return true;
|
||||
}
|
||||
last--;
|
||||
|
|
@ -27,9 +28,10 @@ define([], function () {
|
|||
return false;
|
||||
};
|
||||
|
||||
tree.someIncludingText = function (branch, predicate) {
|
||||
// take the index of the last element in the current branch
|
||||
var last = branch.childNodes.length - 1;
|
||||
// FIXME this isn't being used
|
||||
var someText = tree.someIncludingText = function (root, predicate) {
|
||||
// take the index of the last element in the current root
|
||||
var last = root.childNodes.length - 1;
|
||||
|
||||
// it might be a leaf node
|
||||
if (last < 0) { return false; }
|
||||
|
|
@ -40,12 +42,12 @@ define([], function () {
|
|||
|
||||
// check the node's children (depth first)
|
||||
// if the predicate tests true, return true
|
||||
if (tree.someIncludingText(branch.childNodes[last], predicate)) {
|
||||
if (tree.someIncludingText(root.childNodes[last], predicate)) {
|
||||
return true;
|
||||
} // otherwise none of the nodes inside it matched.
|
||||
|
||||
// check the node itself
|
||||
if (predicate(branch.childNodes[last], last)) {
|
||||
if (predicate(root.childNodes[last], last)) {
|
||||
return true;
|
||||
}
|
||||
last--;
|
||||
|
|
@ -53,6 +55,7 @@ define([], function () {
|
|||
return false;
|
||||
};
|
||||
|
||||
// FIXME not being used
|
||||
tree.findSameHierarchy = function (list, ancestor) {
|
||||
var i = 0;
|
||||
var success = true;
|
||||
|
|
@ -90,117 +93,74 @@ define([], function () {
|
|||
return Array.prototype.indexOf.call(el.parentNode.childNodes, el);
|
||||
};
|
||||
|
||||
var siblingCount = tree.siblingCount = function (el) {
|
||||
return el.parentNodes.childNodes.length;
|
||||
// not being used internally, but is useful externally
|
||||
tree.contains = function (el, root) {
|
||||
return el && root.contains && root.contains(el);
|
||||
};
|
||||
|
||||
var deepestNode = tree.deepestNode = function (el) {
|
||||
var deepest = el.childNodes.length;
|
||||
if (!deepest) { // no children
|
||||
var siblingCount = tree.siblingCount = function (el) {
|
||||
return el.parentNode.childNodes.length;
|
||||
};
|
||||
|
||||
var childCount = tree.childCount = function (el) {
|
||||
return el.childNodes.length;
|
||||
};
|
||||
|
||||
var parentsOf = tree.parentsOf = function (el, root) {
|
||||
var P = [];
|
||||
var p = el;
|
||||
while (p !== root) { P.push((p = p.parentNode)); }
|
||||
return P;
|
||||
};
|
||||
|
||||
/* rightmost and leftmost return the deepest right and left
|
||||
leaf nodes of a tree
|
||||
*/
|
||||
var rightmostNode = tree.rightmostNode = function (el) {
|
||||
var childNodeCount = childCount(el);
|
||||
if (!childNodeCount) { // no children
|
||||
return el; // return the element
|
||||
} else {
|
||||
return deepestNode(el.childNodes[deepest - 1]);
|
||||
return rightmostNode(el.childNodes[childNodeCount - 1]);
|
||||
}
|
||||
};
|
||||
|
||||
var leftMostNode = tree.leftMostNode = function (el) {
|
||||
var left = el.childNodes[0];
|
||||
if (el.childNodes.length) {
|
||||
return leftMostNode(el.childNodes[0]);
|
||||
var leftmostNode = tree.leftmostNode = function (el) {
|
||||
if (childCount(el)) {
|
||||
return leftmostNode(el.childNodes[0]);
|
||||
} else {
|
||||
return el;
|
||||
}
|
||||
};
|
||||
|
||||
/* previousNode and nextNode traverse child elements of the dom
|
||||
in the order in which they appear when selected by a cursor.
|
||||
in particular, these algorithms traverse text nodes, not just tags
|
||||
*/
|
||||
var previousNode = tree.previousNode = function (el, root) {
|
||||
if (!el || el === root) { return null; }
|
||||
|
||||
var i = indexOfNode(el);
|
||||
if (!el.parentNode) { return null; }
|
||||
if (i === 0) {
|
||||
|
||||
if (root && el.parentNode === root.childNodes[0]) { return null; }
|
||||
return deepestNode(previousNode(el.parentNode));
|
||||
return rightmostNode(previousNode(el.parentNode));
|
||||
} else {
|
||||
return el.parentNode.childNodes[i-1];
|
||||
return rightmostNode(el.parentNode.childNodes[i-1])
|
||||
}
|
||||
};
|
||||
|
||||
/* includes text elements */
|
||||
var nextNode = tree.nextNode = function (el, root) {
|
||||
if (!el || el === root) {
|
||||
return null;
|
||||
}
|
||||
if (!el || el === root) { return null; }
|
||||
var i = indexOfNode(el) + 1, // the index of the next node
|
||||
l = el.parentNode.childNodes.length;
|
||||
l = siblingCount(el);
|
||||
if (i === l) { // out of bounds
|
||||
return leftMostNode(nextNode(el.parentNode, root));
|
||||
if (el.parentNode === root) { return null; }
|
||||
return nextNode(el.parentNode, root);
|
||||
} else {
|
||||
return el.parentNode.childNodes[i];
|
||||
return leftmostNode(el.parentNode.childNodes[i], root);
|
||||
}
|
||||
};
|
||||
|
||||
tree.recoverElement = function (el, root) {
|
||||
var tags = tree.tagsUntilElement(el, root);
|
||||
var found = tree.findSameHierarchy(tags, root);
|
||||
var isSame = found === el;
|
||||
console.log("found an equivalent node: %s", isSame);
|
||||
return found;
|
||||
};
|
||||
|
||||
tree.tagsUntilElement = function (el, ancestor) {
|
||||
var list = [];
|
||||
tree.someIncludingText(ancestor, function (e, index) {
|
||||
list.push(e.tagName||e.nodeName);
|
||||
return e === el;
|
||||
});
|
||||
return list;
|
||||
};
|
||||
|
||||
tree.distanceFromEnd = function (el, ancestor) {
|
||||
var i = 0, success = false;
|
||||
// FIXME can't be trusted if element is not found.
|
||||
tree.some(ancestor, function (e, index) {
|
||||
++i;
|
||||
return e === el;
|
||||
});
|
||||
return i;
|
||||
};
|
||||
|
||||
tree.nthFromEnd = function (n, ancestor) {
|
||||
var el = false, i = 0;
|
||||
tree.some(ancestor, function (e) {
|
||||
if (i > n) {
|
||||
// terminate
|
||||
return true;
|
||||
} else {
|
||||
if (++i === n) {
|
||||
el = e;
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
});
|
||||
return el;
|
||||
};
|
||||
|
||||
tree.contains = function (el, ancestor) {
|
||||
return el && ancestor.contains && ancestor.contains(el);
|
||||
};
|
||||
|
||||
tree.check = function (el, ancestor) {
|
||||
return tree.nthFromEnd(tree.distanceFromEnd(el, ancestor), ancestor) === el;
|
||||
};
|
||||
|
||||
// TODO see if we can use this
|
||||
tree.getNext = function (node, parent) {
|
||||
if (node.firstChild) { return node.nextSibling; }
|
||||
do {
|
||||
if(node.nextSibling) { return node.nextSibling; }
|
||||
node = node.parentNode;
|
||||
} while (node && node !== parent);
|
||||
};
|
||||
|
||||
return tree;
|
||||
});
|
||||
|
|
|
|||
Loading…
Reference in a new issue