@plasmicapp/react-web 0.2.178 → 0.2.180

package/dist/react-web.esm.js

@@ -71,6 +71,79 @@ function _extends() {
   };
   return _extends.apply(this, arguments);
 }
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
 function _objectWithoutPropertiesLoose(source, excluded) {
   if (source == null) return {};
   var target = {};
@@ -2305,6 +2378,28 @@ var ARRAY_SYMBOL = /*#__PURE__*/Symbol("[]");
 var PLASMIC_STATE_PROXY_SYMBOL = /*#__PURE__*/Symbol("plasmic.state.proxy");
 var UNINITIALIZED = /*#__PURE__*/Symbol("plasmic.unitialized");
 
+var CyclicStatesReferencesError = /*#__PURE__*/function (_Error2) {
+  _inheritsLoose(CyclicStatesReferencesError, _Error2);
+  function CyclicStatesReferencesError(stateAccessCycle) {
+    return _Error2.call(this, "Cyclic reference found in state initialization: " + stateAccessCycle.join(" -> ")) || this;
+  }
+  return CyclicStatesReferencesError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var InvalidOperation = /*#__PURE__*/function (_Error3) {
+  _inheritsLoose(InvalidOperation, _Error3);
+  function InvalidOperation(msg) {
+    return _Error3.call(this, msg) || this;
+  }
+  return InvalidOperation;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var UnknownError = /*#__PURE__*/function (_Error4) {
+  _inheritsLoose(UnknownError, _Error4);
+  function UnknownError(msg) {
+    return _Error4.call(this, msg) || this;
+  }
+  return UnknownError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
 var StateSpecNode = /*#__PURE__*/function () {
   function StateSpecNode(specs) {
     this._specs = specs;
@@ -2478,7 +2573,7 @@ function getStateCell(target, property) {
 }
 function tryGetStateCellFrom$StateRoot($state, path) {
   if (path.length === 0) {
-    throw new Error("expected a path with length greater than 0");
+    throw new UnknownError("expected a path with length greater than 0");
   }
   var target = _get($state, path.slice(0, -1));
   _get(target, path.slice(-1)); // create state cell;
@@ -2489,15 +2584,33 @@ function getStateCellFrom$StateRoot($state, path) {
 }
 function initializeStateValue($$state, initialStateCell, proxyRoot) {
   var _initialStateCell$ove2;
+  var initialStateName = initialStateCell.node.getSpec().path;
   var stateAccess = new Set();
+  $$state.stateInitializationEnv.visited.add(initialStateName);
+  $$state.stateInitializationEnv.stack.push(initialStateName);
   var $state = create$StateProxy($$state, function (internalStateCell) {
     return {
       get: function get() {
+        var spec = internalStateCell.node.getSpec();
+        if ($$state.stateInitializationEnv.visited.has(spec.path)) {
+          // cyclic reference found
+          var stateAccessCycle = [spec.path];
+          while ($$state.stateInitializationEnv.stack.length > 0) {
+            var curr = $$state.stateInitializationEnv.stack.pop();
+            if (!curr) {
+              break;
+            }
+            stateAccessCycle.push(curr);
+            if (curr === spec.path) {
+              throw new CyclicStatesReferencesError(stateAccessCycle);
+            }
+          }
+          throw new UnknownError("Internal error: cycle not found");
+        }
         var stateCell = getStateCellFrom$StateRoot(proxyRoot, internalStateCell.path);
         stateAccess.add({
           stateCell: stateCell
         });
-        var spec = stateCell.node.getSpec();
         if (spec.valueProp) {
           return $$state.env.$props[spec.valueProp];
         } else if (spec.initFunc && stateCell.initialValue === UNINITIALIZED) {
@@ -2506,7 +2619,7 @@ function initializeStateValue($$state, initialStateCell, proxyRoot) {
         return _get(proxyRoot, stateCell.path);
       },
       set: function set() {
-        throw new Error("Cannot update state values during initialization");
+        throw new InvalidOperation("Cannot update state values during initialization");
       }
     };
   });
@@ -2532,6 +2645,8 @@ function initializeStateValue($$state, initialStateCell, proxyRoot) {
     var _$$state$env$$props$i, _$$state$env$$props;
     (_$$state$env$$props$i = (_$$state$env$$props = $$state.env.$props)[initialSpec.onChangeProp]) == null ? void 0 : _$$state$env$$props$i.call(_$$state$env$$props, initialValue);
   }
+  $$state.stateInitializationEnv.visited["delete"](initialStateName);
+  $$state.stateInitializationEnv.stack.pop();
   return initialValue;
 }
 function create$StateProxy($$state, leafHandlers) {
@@ -2544,7 +2659,7 @@ function create$StateProxy($$state, leafHandlers) {
     var handlers = {
       deleteProperty: function deleteProperty(target, property) {
         if (!isOutside && !currNode.isLeaf() && !currNode.hasArrayTransition() && !isNum(property)) {
-          throw new Error("Can't delete a property in the middle of the state spec");
+          throw new InvalidOperation("Can't delete a property in the middle of the state spec");
         }
         delete _get($$state.stateValues, currPath)[property];
         if (spec.onChangeProp) {
@@ -2605,7 +2720,7 @@ function create$StateProxy($$state, leafHandlers) {
         if (canProxy(value)) {
           target[property] = rec(nextPath, nextNode, isOutside || currNode.isLeaf(), value);
         } else if (!isOutside && !currNode.isLeaf() && !((_nextNode2 = nextNode) != null && _nextNode2.isLeaf())) {
-          throw new Error("inserting a primitive value into a non-leaf");
+          throw new InvalidOperation("inserting a primitive value into a non-leaf");
         } else {
           Reflect.set(target, property, value, receiver);
         }
@@ -2711,7 +2826,11 @@ function useDollarState(specs) {
       stateValues: proxy({}),
       env: envFieldsAreNonNill(env),
       specs: [],
-      registrationsQueue: proxy([])
+      registrationsQueue: proxy([]),
+      stateInitializationEnv: {
+        stack: [],
+        visited: new Set()
+      }
     };
   }()).current;
   $$state.env = envFieldsAreNonNill(env);
@@ -2926,11 +3045,16 @@ function getStateCells($state, root) {
       return getStateCells($state[key], ensure(root.makeTransition(ARRAY_SYMBOL)));
     }));
   } else {
-    return [].concat(stateCells, [].concat(root.edges().entries()).flatMap(function (_ref2) {
-      var key = _ref2[0],
-        child = _ref2[1];
-      return typeof key === "string" && key in $state ? getStateCells($state[key], child) : [];
-    }));
+    var childrenStateCells = [];
+    for (var _iterator3 = _createForOfIteratorHelperLoose(root.edges().entries()), _step3; !(_step3 = _iterator3()).done;) {
+      var _step3$value = _step3.value,
+        key = _step3$value[0],
+        child = _step3$value[1];
+      if (typeof key === "string" && key in $state) {
+        childrenStateCells.push.apply(childrenStateCells, getStateCells($state[key], child));
+      }
+    }
+    return [].concat(stateCells, childrenStateCells);
   }
 }
 function getStateCellsInPlasmicProxy(obj) {