morphdom - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1

dist/morphdom-umd.js

@@ -52,2 +52,12 @@ (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.morphdom = f()}})(function(){var define,module,exports;module={exports:(exports={})};
         }
+    },
+
+    TEXTAREA: function(fromEl, toEl) {
+        var newValue = toEl.value;
+
+        fromEl.value = newValue;
+
+        if (fromEl.firstChild) {
+            fromEl.firstChild.nodeValue = newValue;
+        }
     }
@@ -210,104 +220,106 @@ };
 
-        var curToNodeChild = toEl.firstChild;
-        var curFromNodeChild = fromEl.firstChild;
-        var curToNodeId;
+        if (fromEl.tagName != 'TEXTAREA') {
+            var curToNodeChild = toEl.firstChild;
+            var curFromNodeChild = fromEl.firstChild;
+            var curToNodeId;
 
-        var fromNextSibling;
-        var toNextSibling;
-        var savedEl;
-        var unmatchedEl;
+            var fromNextSibling;
+            var toNextSibling;
+            var savedEl;
+            var unmatchedEl;
 
-        outer: while(curToNodeChild) {
-            toNextSibling = curToNodeChild.nextSibling;
-            curToNodeId = curToNodeChild.id;
+            outer: while(curToNodeChild) {
+                toNextSibling = curToNodeChild.nextSibling;
+                curToNodeId = curToNodeChild.id;
 
-            while(curFromNodeChild) {
-                var curFromNodeId = curFromNodeChild.id;
-                fromNextSibling = curFromNodeChild.nextSibling;
+                while(curFromNodeChild) {
+                    var curFromNodeId = curFromNodeChild.id;
+                    fromNextSibling = curFromNodeChild.nextSibling;
 
-                if (!alreadyVisited) {
-                    if (curFromNodeId && (unmatchedEl = unmatchedEls[curFromNodeId])) {
-                        unmatchedEl.parentNode.replaceChild(curFromNodeChild, unmatchedEl);
-                        morphEl(curFromNodeChild, unmatchedEl, alreadyVisited);
-                        curFromNodeChild = fromNextSibling;
-                        continue;
+                    if (!alreadyVisited) {
+                        if (curFromNodeId && (unmatchedEl = unmatchedEls[curFromNodeId])) {
+                            unmatchedEl.parentNode.replaceChild(curFromNodeChild, unmatchedEl);
+                            morphEl(curFromNodeChild, unmatchedEl, alreadyVisited);
+                            curFromNodeChild = fromNextSibling;
+                            continue;
+                        }
                     }
-                }
 
-                var curFromNodeType = curFromNodeChild.nodeType;
+                    var curFromNodeType = curFromNodeChild.nodeType;
 
-                if (curFromNodeType === curToNodeChild.nodeType) {
-                    var isCompatible = false;
+                    if (curFromNodeType === curToNodeChild.nodeType) {
+                        var isCompatible = false;
 
-                    if (curFromNodeType === 1) { // Both nodes being compared are Element nodes
-                        if (curFromNodeChild.tagName === curToNodeChild.tagName) {
-                            // We have compatible DOM elements
-                            if (curFromNodeId || curToNodeId) {
-                                // If either DOM element has an ID then we handle
-                                // those differently since we want to match up
-                                // by ID
-                                if (curToNodeId === curFromNodeId) {
+                        if (curFromNodeType === 1) { // Both nodes being compared are Element nodes
+                            if (curFromNodeChild.tagName === curToNodeChild.tagName) {
+                                // We have compatible DOM elements
+                                if (curFromNodeId || curToNodeId) {
+                                    // If either DOM element has an ID then we handle
+                                    // those differently since we want to match up
+                                    // by ID
+                                    if (curToNodeId === curFromNodeId) {
+                                        isCompatible = true;
+                                    }
+                                } else {
                                     isCompatible = true;
                                 }
-                            } else {
-                                isCompatible = true;
                             }
+
+                            if (isCompatible) {
+                                // We found compatible DOM elements so transform the current "from" node
+                                // to match the current target DOM node.
+                                morphEl(curFromNodeChild, curToNodeChild, alreadyVisited);
+                            }
+                        } else if (curFromNodeType === 3) { // Both nodes being compared are Text nodes
+                            isCompatible = true;
+                            // Simply update nodeValue on the original node to change the text value
+                            curFromNodeChild.nodeValue = curToNodeChild.nodeValue;
                         }
 
                         if (isCompatible) {
-                            // We found compatible DOM elements so transform the current "from" node
-                            // to match the current target DOM node.
-                            morphEl(curFromNodeChild, curToNodeChild, alreadyVisited);
+                            curToNodeChild = toNextSibling;
+                            curFromNodeChild = fromNextSibling;
+                            continue outer;
                         }
-                    } else if (curFromNodeType === 3) { // Both nodes being compared are Text nodes
-                        isCompatible = true;
-                        // Simply update nodeValue on the original node to change the text value
-                        curFromNodeChild.nodeValue = curToNodeChild.nodeValue;
                     }
 
-                    if (isCompatible) {
-                        curToNodeChild = toNextSibling;
-                        curFromNodeChild = fromNextSibling;
-                        continue outer;
+                    // No compatible match so remove the old node from the DOM and continue trying
+                    // to find a match in the original DOM
+                    removeNode(curFromNodeChild, fromEl, alreadyVisited);
+                    curFromNodeChild = fromNextSibling;
+                }
+
+                if (curToNodeId) {
+                    if ((savedEl = savedEls[curToNodeId])) {
+                        morphEl(savedEl, curToNodeChild, true);
+                        curToNodeChild = savedEl; // We want to append the saved element instead
+                    } else {
+                        // The current DOM element in the target tree has an ID
+                        // but we did not find a match in any of the corresponding
+                        // siblings. We just put the target element in the old DOM tree
+                        // but if we later find an element in the old DOM tree that has
+                        // a matching ID then we will replace the target element
+                        // with the corresponding old element and morph the old element
+                        unmatchedEls[curToNodeId] = curToNodeChild;
                     }
                 }
 
-                // No compatible match so remove the old node from the DOM and continue trying
-                // to find a match in the original DOM
-                removeNode(curFromNodeChild, fromEl, alreadyVisited);
+                // If we got this far then we did not find a candidate match for our "to node"
+                // and we exhausted all of the children "from" nodes. Therefore, we will just
+                // append the current "to node" to the end
+                fromEl.appendChild(curToNodeChild);
+
+                curToNodeChild = toNextSibling;
                 curFromNodeChild = fromNextSibling;
             }
 
-            if (curToNodeId) {
-                if ((savedEl = savedEls[curToNodeId])) {
-                    morphEl(savedEl, curToNodeChild, true);
-                    curToNodeChild = savedEl; // We want to append the saved element instead
-                } else {
-                    // The current DOM element in the target tree has an ID
-                    // but we did not find a match in any of the corresponding
-                    // siblings. We just put the target element in the old DOM tree
-                    // but if we later find an element in the old DOM tree that has
-                    // a matching ID then we will replace the target element
-                    // with the corresponding old element and morph the old element
-                    unmatchedEls[curToNodeId] = curToNodeChild;
-                }
+            // We have processed all of the "to nodes". If curFromNodeChild is non-null then
+            // we still have some from nodes left over that need to be removed
+            while(curFromNodeChild) {
+                fromNextSibling = curFromNodeChild.nextSibling;
+                removeNode(curFromNodeChild, fromEl, alreadyVisited);
+                curFromNodeChild = fromNextSibling;
             }
-
-            // If we got this far then we did not find a candidate match for our "to node"
-            // and we exhausted all of the children "from" nodes. Therefore, we will just
-            // append the current "to node" to the end
-            fromEl.appendChild(curToNodeChild);
-
-            curToNodeChild = toNextSibling;
-            curFromNodeChild = fromNextSibling;
         }
 
-        // We have processed all of the "to nodes". If curFromNodeChild is non-null then
-        // we still have some from nodes left over that need to be removed
-        while(curFromNodeChild) {
-            fromNextSibling = curFromNodeChild.nextSibling;
-            removeNode(curFromNodeChild, fromEl, alreadyVisited);
-            curFromNodeChild = fromNextSibling;
-        }
-
         var specialElHandler = specialElHandlers[fromEl.tagName];
@@ -314,0 +326,0 @@ if (specialElHandler) {

lib/index.js

@@ -51,2 +51,12 @@ // Create a range object for efficently rendering strings to elements.
         }
+    },
+
+    TEXTAREA: function(fromEl, toEl) {
+        var newValue = toEl.value;
+
+        fromEl.value = newValue;
+
+        if (fromEl.firstChild) {
+            fromEl.firstChild.nodeValue = newValue;
+        }
     }
@@ -209,104 +219,106 @@ };
 
-        var curToNodeChild = toEl.firstChild;
-        var curFromNodeChild = fromEl.firstChild;
-        var curToNodeId;
+        if (fromEl.tagName != 'TEXTAREA') {
+            var curToNodeChild = toEl.firstChild;
+            var curFromNodeChild = fromEl.firstChild;
+            var curToNodeId;
 
-        var fromNextSibling;
-        var toNextSibling;
-        var savedEl;
-        var unmatchedEl;
+            var fromNextSibling;
+            var toNextSibling;
+            var savedEl;
+            var unmatchedEl;
 
-        outer: while(curToNodeChild) {
-            toNextSibling = curToNodeChild.nextSibling;
-            curToNodeId = curToNodeChild.id;
+            outer: while(curToNodeChild) {
+                toNextSibling = curToNodeChild.nextSibling;
+                curToNodeId = curToNodeChild.id;
 
-            while(curFromNodeChild) {
-                var curFromNodeId = curFromNodeChild.id;
-                fromNextSibling = curFromNodeChild.nextSibling;
+                while(curFromNodeChild) {
+                    var curFromNodeId = curFromNodeChild.id;
+                    fromNextSibling = curFromNodeChild.nextSibling;
 
-                if (!alreadyVisited) {
-                    if (curFromNodeId && (unmatchedEl = unmatchedEls[curFromNodeId])) {
-                        unmatchedEl.parentNode.replaceChild(curFromNodeChild, unmatchedEl);
-                        morphEl(curFromNodeChild, unmatchedEl, alreadyVisited);
-                        curFromNodeChild = fromNextSibling;
-                        continue;
+                    if (!alreadyVisited) {
+                        if (curFromNodeId && (unmatchedEl = unmatchedEls[curFromNodeId])) {
+                            unmatchedEl.parentNode.replaceChild(curFromNodeChild, unmatchedEl);
+                            morphEl(curFromNodeChild, unmatchedEl, alreadyVisited);
+                            curFromNodeChild = fromNextSibling;
+                            continue;
+                        }
                     }
-                }
 
-                var curFromNodeType = curFromNodeChild.nodeType;
+                    var curFromNodeType = curFromNodeChild.nodeType;
 
-                if (curFromNodeType === curToNodeChild.nodeType) {
-                    var isCompatible = false;
+                    if (curFromNodeType === curToNodeChild.nodeType) {
+                        var isCompatible = false;
 
-                    if (curFromNodeType === 1) { // Both nodes being compared are Element nodes
-                        if (curFromNodeChild.tagName === curToNodeChild.tagName) {
-                            // We have compatible DOM elements
-                            if (curFromNodeId || curToNodeId) {
-                                // If either DOM element has an ID then we handle
-                                // those differently since we want to match up
-                                // by ID
-                                if (curToNodeId === curFromNodeId) {
+                        if (curFromNodeType === 1) { // Both nodes being compared are Element nodes
+                            if (curFromNodeChild.tagName === curToNodeChild.tagName) {
+                                // We have compatible DOM elements
+                                if (curFromNodeId || curToNodeId) {
+                                    // If either DOM element has an ID then we handle
+                                    // those differently since we want to match up
+                                    // by ID
+                                    if (curToNodeId === curFromNodeId) {
+                                        isCompatible = true;
+                                    }
+                                } else {
                                     isCompatible = true;
                                 }
-                            } else {
-                                isCompatible = true;
                             }
+
+                            if (isCompatible) {
+                                // We found compatible DOM elements so transform the current "from" node
+                                // to match the current target DOM node.
+                                morphEl(curFromNodeChild, curToNodeChild, alreadyVisited);
+                            }
+                        } else if (curFromNodeType === 3) { // Both nodes being compared are Text nodes
+                            isCompatible = true;
+                            // Simply update nodeValue on the original node to change the text value
+                            curFromNodeChild.nodeValue = curToNodeChild.nodeValue;
                         }
 
                         if (isCompatible) {
-                            // We found compatible DOM elements so transform the current "from" node
-                            // to match the current target DOM node.
-                            morphEl(curFromNodeChild, curToNodeChild, alreadyVisited);
+                            curToNodeChild = toNextSibling;
+                            curFromNodeChild = fromNextSibling;
+                            continue outer;
                         }
-                    } else if (curFromNodeType === 3) { // Both nodes being compared are Text nodes
-                        isCompatible = true;
-                        // Simply update nodeValue on the original node to change the text value
-                        curFromNodeChild.nodeValue = curToNodeChild.nodeValue;
                     }
 
-                    if (isCompatible) {
-                        curToNodeChild = toNextSibling;
-                        curFromNodeChild = fromNextSibling;
-                        continue outer;
+                    // No compatible match so remove the old node from the DOM and continue trying
+                    // to find a match in the original DOM
+                    removeNode(curFromNodeChild, fromEl, alreadyVisited);
+                    curFromNodeChild = fromNextSibling;
+                }
+
+                if (curToNodeId) {
+                    if ((savedEl = savedEls[curToNodeId])) {
+                        morphEl(savedEl, curToNodeChild, true);
+                        curToNodeChild = savedEl; // We want to append the saved element instead
+                    } else {
+                        // The current DOM element in the target tree has an ID
+                        // but we did not find a match in any of the corresponding
+                        // siblings. We just put the target element in the old DOM tree
+                        // but if we later find an element in the old DOM tree that has
+                        // a matching ID then we will replace the target element
+                        // with the corresponding old element and morph the old element
+                        unmatchedEls[curToNodeId] = curToNodeChild;
                     }
                 }
 
-                // No compatible match so remove the old node from the DOM and continue trying
-                // to find a match in the original DOM
-                removeNode(curFromNodeChild, fromEl, alreadyVisited);
+                // If we got this far then we did not find a candidate match for our "to node"
+                // and we exhausted all of the children "from" nodes. Therefore, we will just
+                // append the current "to node" to the end
+                fromEl.appendChild(curToNodeChild);
+
+                curToNodeChild = toNextSibling;
                 curFromNodeChild = fromNextSibling;
             }
 
-            if (curToNodeId) {
-                if ((savedEl = savedEls[curToNodeId])) {
-                    morphEl(savedEl, curToNodeChild, true);
-                    curToNodeChild = savedEl; // We want to append the saved element instead
-                } else {
-                    // The current DOM element in the target tree has an ID
-                    // but we did not find a match in any of the corresponding
-                    // siblings. We just put the target element in the old DOM tree
-                    // but if we later find an element in the old DOM tree that has
-                    // a matching ID then we will replace the target element
-                    // with the corresponding old element and morph the old element
-                    unmatchedEls[curToNodeId] = curToNodeChild;
-                }
+            // We have processed all of the "to nodes". If curFromNodeChild is non-null then
+            // we still have some from nodes left over that need to be removed
+            while(curFromNodeChild) {
+                fromNextSibling = curFromNodeChild.nextSibling;
+                removeNode(curFromNodeChild, fromEl, alreadyVisited);
+                curFromNodeChild = fromNextSibling;
             }
-
-            // If we got this far then we did not find a candidate match for our "to node"
-            // and we exhausted all of the children "from" nodes. Therefore, we will just
-            // append the current "to node" to the end
-            fromEl.appendChild(curToNodeChild);
-
-            curToNodeChild = toNextSibling;
-            curFromNodeChild = fromNextSibling;
         }
 
-        // We have processed all of the "to nodes". If curFromNodeChild is non-null then
-        // we still have some from nodes left over that need to be removed
-        while(curFromNodeChild) {
-            fromNextSibling = curFromNodeChild.nextSibling;
-            removeNode(curFromNodeChild, fromEl, alreadyVisited);
-            curFromNodeChild = fromNextSibling;
-        }
-
         var specialElHandler = specialElHandlers[fromEl.tagName];
@@ -313,0 +325,0 @@ if (specialElHandler) {

package.json

@@ -38,3 +38,3 @@ {
     "dependencies": {},
-    "version": "1.0.0"
+    "version": "1.0.1"
 }

README.md

@@ -5,2 +5,3 @@ morphdom
 [![Build Status](https://travis-ci.org/patrick-steele-idem/morphdom.svg?branch=master)](https://travis-ci.org/patrick-steele-idem/morphdom)
+[![NPM](https://nodei.co/npm/morphdom.png)](https://www.npmjs.com/package/morphdom)
 
@@ -7,0 +8,0 @@ Lightweight module for morphing an existing DOM node tree to match a target DOM node tree. It's fast and works with the real DOM—no virtual DOM here!

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

13968168

increased by6.76%

Number of package files

638

increased by4.08%

Lines of code

664

increased by2.79%

Number of lines in readme file

476

increased by0.21%

No dependency changes