sproutjs-core 2.6.0 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sproutjs-core",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "keywords": [],
   "author": "",
   "license": "ISC",

package/sprout-core.js

@@ -678,11 +678,13 @@ var COMMANDS = {
       theState._stateManager.addStateMap(stateItemsPropertyName, customElementName, thiselement);
     });
   },
-  text: function text(commandValue) {
-    var stateProp = commandValue;
-    this.initialSetText(stateProp);
-    // DO NOT CALL .normalize()! It might change the Text Nodes!
+  /*
+  text: function(commandValue) {
+      const stateProp = commandValue;
+      this.initialSetText(stateProp);
+      // DO NOT CALL .normalize()! It might change the Text Nodes!
   },
+  */
   bind: function bind(commandValue) {
     if (true) {
       if (this.tagName !== "INPUT") {
@@ -725,12 +727,6 @@ var COMMANDS = {
   }
 };
 ;// ./src/shared/parse_utils.js
-function parse_utils_toConsumableArray(r) { return parse_utils_arrayWithoutHoles(r) || parse_utils_iterableToArray(r) || parse_utils_unsupportedIterableToArray(r) || parse_utils_nonIterableSpread(); }
-function parse_utils_nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function parse_utils_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return parse_utils_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? parse_utils_arrayLikeToArray(r, a) : void 0; } }
-function parse_utils_iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function parse_utils_arrayWithoutHoles(r) { if (Array.isArray(r)) return parse_utils_arrayLikeToArray(r); }
-function parse_utils_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /* Possible expression:
  * literal: straight state prop,.
  * negation: !something (not something)
@@ -738,8 +734,11 @@ function parse_utils_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a
  * ternary: somethingIsTruthy?returnThis:[elseThis]
  */
 function parseStateExpression(expression) {
+  if (expression.indexOf('@') === 0) {
+    return ["property", [expression.substring(1)]];
+  }
   if (expression.indexOf('!') === 0) {
-    return ["negation", expression.substring(1)];
+    return ["negation", [expression.substring(1)]];
   }
   var charIndex = 0;
   var parsed = expression[charIndex];
@@ -747,14 +746,14 @@ function parseStateExpression(expression) {
   while (charIndex++ < expression.length) {
     _char = expression[charIndex];
     if (charIndex == 3 && parsed == "is_") {
-      return ["equality"].concat(parse_utils_toConsumableArray(expression.substring(3).split(':')));
+      return ["equality", expression.substring(3).split(':')];
     }
     if (_char === '?') {
-      return ["ternary", parsed].concat(parse_utils_toConsumableArray(expression.substring(charIndex + 1).split(':')));
+      return ["ternary", parsed, expression.substring(charIndex + 1).split(':')];
     }
     parsed += _char;
   }
-  return ["literal", expression];
+  return ["literal", [expression]];
 }
 function fromAttributeValue(value) {
   if (value === '') return true;
@@ -846,14 +845,14 @@ function extendElementClassWithReactiveElementClass(elementClass) {
           _step;
         try {
           for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var attrName = _step.value;
-            var attrValue = this.getAttribute(attrName);
+            var _attrName = _step.value;
+            var attrValue = this.getAttribute(_attrName);
             // This also resolves "State attributes"
-            this.initialSetAttribute(attrName, attrValue);
+            this.initialSetAttribute(_attrName, attrValue);
 
             // Save "Command attributes"
-            if (attrName.indexOf('_') === 0) {
-              var command = attrName.substring(1);
+            if (_attrName.indexOf('_') === 0) {
+              var command = _attrName.substring(1);
               commands.push({
                 command: command,
                 args: attrValue
@@ -903,11 +902,19 @@ function extendElementClassWithReactiveElementClass(elementClass) {
         // getRootNode - returns shadowRoot if this is inside shadow DOM, and document if it's in light DOM.
         var rootNode = this.getRootNode();
 
-        // If this is inside light DOM - we take the direct parent,
+        // If this is inside light DOM and the parent is a Sprout custom element - we take the direct parent,
         // this works e.g. with a light element with "slot" attribute, inside a Sprout component
         // (It will have access to its "state")
 
-        this.host = rootNode === document ? this.parentElement : rootNode.host;
+        if (rootNode !== document) {
+          this.host = rootNode.host;
+        } else if (isReactiveCustomElement(this.parentElement)) {
+          this.host = this.parentElement;
+        } else {
+          // This could mean this is actually a top-level Sprout Custom Element ("host"),
+          // i.e. a custom element that is not inside shadowDOM
+          roost.host = null;
+        }
         if (this.host) {
           // Once the host custom element is connected
           // then its 'State' is ready and activated,
@@ -1039,8 +1046,12 @@ function extendElementClassWithReactiveElementClass(elementClass) {
             }
           }
           var stateProp = attributeValue;
-          var attrName = attributeName.substring(1);
-          setStateAttribute.call(this, attrName, stateProp);
+          var _attrName2 = attributeName.substring(1);
+          if (_attrName2 === "textContent") {
+            this.initialSetText(stateProp);
+          } else {
+            setStateAttribute.call(this, _attrName2, stateProp);
+          }
         } else {
           if (isPropAttr) {
             var host = this.getHost();
@@ -1053,7 +1064,11 @@ function extendElementClassWithReactiveElementClass(elementClass) {
             var propValue = host.getAttribute(propName);
             valueToSet = propValue;
           }
-          setAttribute.call(this, attributeName, valueToSet);
+          if (attrName === "textContent") {
+            this.initialSetText(valueToSet);
+          } else {
+            setAttribute.call(this, attributeName, valueToSet);
+          }
         }
       }
     }, {