marko 4.28.6 → 4.28.8

package/dist/runtime/components/Component.js

@@ -3,10 +3,10 @@
 
 var domInsert = require("../dom-insert");
 var defaultCreateOut = require("../createOut");
-var getComponentsContext = require("./ComponentsContext").U_;
+var getComponentsContext = require("./ComponentsContext").V_;
 var componentsUtil = require("@internal/components-util");
-var componentLookup = componentsUtil._n_;
-var destroyNodeRecursive = componentsUtil._S_;
+var componentLookup = componentsUtil._o_;
+var destroyNodeRecursive = componentsUtil._T_;
 var EventEmitter = require("events-light");
 var RenderResult = require("../RenderResult");
 var SubscriptionTracker = require("listener-tracker");
@@ -15,8 +15,8 @@ var updateManager = require("./update-manager");
 var morphdom = require("../vdom/morphdom");
 var eventDelegation = require("./event-delegation");
 var domData = require("./dom-data");
-var componentsByDOMNode = domData._q_;
-var keyedElementsByComponentId = domData._p_;
+var componentsByDOMNode = domData._r_;
+var keyedElementsByComponentId = domData._q_;
 var CONTEXT_KEY = "__subtree_context__";
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -58,7 +58,7 @@ function handleCustomEventWithMethodListener(component, targetMethodName, args,
     args = extraArgs.concat(args);
   }
 
-  var targetComponent = componentLookup[component.Y_];
+  var targetComponent = componentLookup[component.Z_];
   var targetMethod = typeof targetMethodName === "function" ? targetMethodName : targetComponent[targetMethodName];
   if (!targetMethod) {
     throw Error("Method not found: " + targetMethodName);
@@ -117,8 +117,8 @@ function processUpdateHandlers(component, stateChanges, oldState) {
       handlerMethod.call(component, newValue, oldValue);
     });
 
-    component._y_();
-    component._t_();
+    component._z_();
+    component._u_();
   }
 
   return true;
@@ -158,50 +158,50 @@ var componentProto;
 function Component(id) {
   EventEmitter.call(this);
   this.id = id;
-  this.C_ = null;
-  this._E_ = null;
-  this.ak_ = null;
-  this._w_ = null;
-  this.Z_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
-  this.X_ = null;
-  this.Y_ = null;
+  this.D_ = null;
+  this._F_ = null;
   this.al_ = null;
-  this.R_ = undefined;
-  this._x_ = false;
-  this.am_ = undefined;
-  this.L_ = false;
-  this._c_ = false;
-  this.an_ = false;
+  this._x_ = null;
+  this.___ = null; // Used to keep track of bubbling DOM events for components rendered on the server
+  this.Y_ = null;
+  this.Z_ = null;
+  this.am_ = null;
+  this.S_ = undefined;
+  this._y_ = false;
+  this.an_ = undefined;
+  this.M_ = false;
+  this._d_ = false;
   this.ao_ = false;
-  this.E_ = undefined;
+  this.ap_ = false;
+  this.F_ = undefined;
 
   var ssrKeyedElements = keyedElementsByComponentId[id];
 
   if (ssrKeyedElements) {
-    this.N_ = ssrKeyedElements;
+    this.O_ = ssrKeyedElements;
     delete keyedElementsByComponentId[id];
   } else {
-    this.N_ = {};
+    this.O_ = {};
   }
 }
 
 Component.prototype = componentProto = {
-  A_: true,
+  B_: true,
 
   subscribeTo: function (target) {
     if (!target) {
       throw TypeError();
     }
 
-    var subscriptions = this.ak_ || (this.ak_ = new SubscriptionTracker());
+    var subscriptions = this.al_ || (this.al_ = new SubscriptionTracker());
 
-    var subscribeToOptions = target.A_ ? COMPONENT_SUBSCRIBE_TO_OPTIONS : NON_COMPONENT_SUBSCRIBE_TO_OPTIONS;
+    var subscribeToOptions = target.B_ ? COMPONENT_SUBSCRIBE_TO_OPTIONS : NON_COMPONENT_SUBSCRIBE_TO_OPTIONS;
 
     return subscriptions.subscribeTo(target, subscribeToOptions);
   },
 
   emit: function (eventType) {
-    var customEvents = this.X_;
+    var customEvents = this.Y_;
     var target;
 
     if (customEvents && (target = customEvents[eventType])) {
@@ -228,10 +228,10 @@ Component.prototype = componentProto = {
   getEl: function (key, index) {
     if (key) {
       var resolvedKey = resolveKeyHelper(key, index);
-      var keyedElement = this.N_["@" + resolvedKey];
+      var keyedElement = this.O_["@" + resolvedKey];
 
       if (!keyedElement) {
-        var keyedComponentRoot = this.N_[resolvedKey];
+        var keyedComponentRoot = this.O_[resolvedKey];
 
         if (keyedComponentRoot) {
           return keyedComponentRoot.nodeType === 1 /** Node.ELEMENT_NODE */
@@ -257,33 +257,33 @@ Component.prototype = componentProto = {
     return els;
   },
   getComponent: function (key, index) {
-    var rootNode = this.N_[resolveKeyHelper(key, index)];
+    var rootNode = this.O_[resolveKeyHelper(key, index)];
     if (/\[\]$/.test(key)) {
       rootNode = rootNode && rootNode[Object.keys(rootNode)[0]];
     }
     return rootNode && componentsByDOMNode.get(rootNode);
   },
   getComponents: function (key) {
-    var lookup = this.N_[key + "[]"];
+    var lookup = this.O_[key + "[]"];
     return lookup ? Object.keys(lookup).map(function (key) {
       return componentsByDOMNode.get(lookup[key]);
     }).filter(Boolean) : [];
   },
   destroy: function () {
-    if (this.L_) {
+    if (this.M_) {
       return;
     }
 
-    var root = this._E_;
+    var root = this._F_;
 
-    this._O_();
+    this._P_();
 
     var nodes = root.nodes;
 
     nodes.forEach(function (node) {
       destroyNodeRecursive(node);
 
-      if (eventDelegation.ap_(node) !== false) {
+      if (eventDelegation.aq_(node) !== false) {
         node.parentNode.removeChild(node);
       }
     });
@@ -291,129 +291,129 @@ Component.prototype = componentProto = {
     root.detached = true;
 
     delete componentLookup[this.id];
-    this.N_ = {};
+    this.O_ = {};
   },
 
-  _O_: function () {
-    if (this.L_) {
+  _P_: function () {
+    if (this.M_) {
       return;
     }
 
-    this.aq_();
-    this.L_ = true;
+    this.ar_();
+    this.M_ = true;
 
-    componentsByDOMNode.set(this._E_, undefined);
+    componentsByDOMNode.set(this._F_, undefined);
 
-    this._E_ = null;
+    this._F_ = null;
 
     // Unsubscribe from all DOM events
-    this._v_();
+    this._w_();
 
-    var subscriptions = this.ak_;
+    var subscriptions = this.al_;
     if (subscriptions) {
       subscriptions.removeAllListeners();
-      this.ak_ = null;
+      this.al_ = null;
     }
   },
 
   isDestroyed: function () {
-    return this.L_;
+    return this.M_;
   },
   get state() {
-    return this.C_;
+    return this.D_;
   },
   set state(newState) {
-    var state = this.C_;
+    var state = this.D_;
     if (!state && !newState) {
       return;
     }
 
     if (!state) {
-      state = this.C_ = new this.S_(this);
+      state = this.D_ = new this.T_(this);
     }
 
-    state.ar_(newState || {});
+    state.as_(newState || {});
 
-    if (state.an_) {
-      this.as_();
+    if (state.ao_) {
+      this.at_();
     }
 
     if (!newState) {
-      this.C_ = null;
+      this.D_ = null;
     }
   },
   setState: function (name, value) {
-    var state = this.C_;
+    var state = this.D_;
 
     if (!state) {
-      state = this.C_ = new this.S_(this);
+      state = this.D_ = new this.T_(this);
     }
     if (typeof name == "object") {
       // Merge in the new state with the old state
       var newState = name;
       for (var k in newState) {
         if (hasOwnProperty.call(newState, k)) {
-          state.at_(k, newState[k], true /* ensure:true */);
+          state.au_(k, newState[k], true /* ensure:true */);
         }
       }
     } else {
-      state.at_(name, value, true /* ensure:true */);
+      state.au_(name, value, true /* ensure:true */);
     }
   },
 
   setStateDirty: function (name, value) {
-    var state = this.C_;
+    var state = this.D_;
 
     if (arguments.length == 1) {
       value = state[name];
     }
 
-    state.at_(name, value, true /* ensure:true */
+    state.au_(name, value, true /* ensure:true */
     , true /* forceDirty:true */
     );
   },
 
   replaceState: function (newState) {
-    this.C_.ar_(newState);
+    this.D_.as_(newState);
   },
 
   get input() {
-    return this.R_;
+    return this.S_;
   },
   set input(newInput) {
-    if (this.ao_) {
-      this.R_ = newInput;
+    if (this.ap_) {
+      this.S_ = newInput;
     } else {
-      this._l_(newInput);
+      this._m_(newInput);
     }
   },
 
-  _l_: function (newInput, onInput, out) {
+  _m_: function (newInput, onInput, out) {
     onInput = onInput || this.onInput;
     var updatedInput;
 
-    var oldInput = this.R_;
-    this.R_ = undefined;
-    this.au_ = out && out[CONTEXT_KEY] || this.au_;
+    var oldInput = this.S_;
+    this.S_ = undefined;
+    this.av_ = out && out[CONTEXT_KEY] || this.av_;
 
     if (onInput) {
       // We need to set a flag to preview `this.input = foo` inside
       // onInput causing infinite recursion
-      this.ao_ = true;
+      this.ap_ = true;
       updatedInput = onInput.call(this, newInput || {}, out);
-      this.ao_ = false;
+      this.ap_ = false;
     }
 
-    newInput = this.al_ = updatedInput || newInput;
+    newInput = this.am_ = updatedInput || newInput;
 
-    if (this.an_ = checkInputChanged(this, oldInput, newInput)) {
-      this.as_();
+    if (this.ao_ = checkInputChanged(this, oldInput, newInput)) {
+      this.at_();
     }
 
-    if (this.R_ === undefined) {
-      this.R_ = newInput;
+    if (this.S_ === undefined) {
+      this.S_ = newInput;
       if (newInput && newInput.$global) {
-        this.am_ = newInput.$global;
+        this.an_ = newInput.$global;
       }
     }
 
@@ -421,54 +421,54 @@ Component.prototype = componentProto = {
   },
 
   forceUpdate: function () {
-    this.an_ = true;
-    this.as_();
+    this.ao_ = true;
+    this.at_();
   },
 
-  as_: function () {
-    if (!this._c_) {
-      this._c_ = true;
-      updateManager.av_(this);
+  at_: function () {
+    if (!this._d_) {
+      this._d_ = true;
+      updateManager.aw_(this);
     }
   },
 
   update: function () {
-    if (this.L_ === true || this.aw_ === false) {
+    if (this.M_ === true || this.ax_ === false) {
       return;
     }
 
-    var input = this.R_;
-    var state = this.C_;
+    var input = this.S_;
+    var state = this.D_;
 
-    if (this.an_ === false && state !== null && state.an_ === true) {
-      if (processUpdateHandlers(this, state.ax_, state.ay_, state)) {
-        state.an_ = false;
+    if (this.ao_ === false && state !== null && state.ao_ === true) {
+      if (processUpdateHandlers(this, state.ay_, state.az_, state)) {
+        state.ao_ = false;
       }
     }
 
-    if (this.aw_ === true) {
+    if (this.ax_ === true) {
       // The UI component is still dirty after process state handlers
       // then we should rerender
 
       if (this.shouldUpdate(input, state) !== false) {
-        this.az_();
+        this.aA_();
       }
     }
 
-    this._t_();
+    this._u_();
   },
 
-  get aw_() {
-    return this.an_ === true || this.C_ !== null && this.C_.an_ === true;
+  get ax_() {
+    return this.ao_ === true || this.D_ !== null && this.D_.ao_ === true;
   },
 
-  _t_: function () {
-    this.an_ = false;
-    this._c_ = false;
-    this.al_ = null;
-    var state = this.C_;
+  _u_: function () {
+    this.ao_ = false;
+    this._d_ = false;
+    this.am_ = null;
+    var state = this.D_;
     if (state) {
-      state._t_();
+      state._u_();
     }
   },
 
@@ -476,72 +476,72 @@ Component.prototype = componentProto = {
     return true;
   },
 
-  az_: function () {
+  aA_: function () {
     var self = this;
-    var renderer = self.T_;
+    var renderer = self.U_;
 
     if (!renderer) {
       throw TypeError();
     }
 
-    var input = this.al_ || this.R_;
+    var input = this.am_ || this.S_;
 
-    updateManager.aA_(function () {
-      self._F_(input, false).afterInsert(self.E_);
+    updateManager.aB_(function () {
+      self._G_(input, false).afterInsert(self.F_);
     });
 
-    this._t_();
+    this._u_();
   },
 
-  _F_: function (input, isHydrate) {
-    var host = this.E_;
-    var globalData = this.am_;
-    var rootNode = this._E_;
-    var renderer = this.T_;
+  _G_: function (input, isHydrate) {
+    var host = this.F_;
+    var globalData = this.an_;
+    var rootNode = this._F_;
+    var renderer = this.U_;
     var createOut = renderer.createOut || defaultCreateOut;
     var out = createOut(globalData);
     out.sync();
-    out.E_ = this.E_;
-    out[CONTEXT_KEY] = this.au_;
+    out.F_ = this.F_;
+    out[CONTEXT_KEY] = this.av_;
 
     var componentsContext = getComponentsContext(out);
-    var globalComponentsContext = componentsContext.r_;
-    globalComponentsContext.aB_ = this;
-    globalComponentsContext.a__ = isHydrate;
+    var globalComponentsContext = componentsContext.s_;
+    globalComponentsContext.aC_ = this;
+    globalComponentsContext.aa_ = isHydrate;
 
     renderer(input, out);
 
     var result = new RenderResult(out);
 
-    var targetNode = out.aj_().a_;
+    var targetNode = out.ak_().a_;
 
     morphdom(rootNode, targetNode, host, componentsContext);
 
     return result;
   },
 
-  aC_: function () {
-    var root = this._E_;
+  aD_: function () {
+    var root = this._F_;
     root.remove();
     return root;
   },
 
-  _v_: function () {
-    var eventListenerHandles = this._w_;
+  _w_: function () {
+    var eventListenerHandles = this._x_;
     if (eventListenerHandles) {
       eventListenerHandles.forEach(removeListener);
-      this._w_ = null;
+      this._x_ = null;
     }
   },
 
-  get aD_() {
-    var state = this.C_;
-    return state && state.D_;
+  get aE_() {
+    var state = this.D_;
+    return state && state.E_;
   },
 
-  aE_: function (customEvents, scope) {
-    var finalCustomEvents = this.X_ = {};
-    this.Y_ = scope;
+  aF_: function (customEvents, scope) {
+    var finalCustomEvents = this.Y_ = {};
+    this.Z_ = scope;
 
     customEvents.forEach(function (customEvent) {
       var eventType = customEvent[0];
@@ -556,45 +556,45 @@ Component.prototype = componentProto = {
   },
 
   get el() {
-    return walkFragments(this._E_);
+    return walkFragments(this._F_);
   },
 
   get els() {
-    return (this._E_ ? this._E_.nodes : []).filter(function (el) {
+    return (this._F_ ? this._F_.nodes : []).filter(function (el) {
       return el.nodeType === ELEMENT_NODE;
     });
   },
 
-  aF_: emit,
-  aG_(input, out) {
+  aG_: emit,
+  aH_(input, out) {
     this.onCreate && this.onCreate(input, out);
-    this.aF_("create", input, out);
+    this.aG_("create", input, out);
   },
 
-  aH_(out) {
+  aI_(out) {
     this.onRender && this.onRender(out);
-    this.aF_("render", out);
+    this.aG_("render", out);
   },
 
-  _y_() {
+  _z_() {
     this.onUpdate && this.onUpdate();
-    this.aF_("update");
+    this.aG_("update");
   },
 
-  _z_() {
+  _A_() {
     this.onMount && this.onMount();
-    this.aF_("mount");
+    this.aG_("mount");
   },
 
-  aq_() {
+  ar_() {
     this.onDestroy && this.onDestroy();
-    this.aF_("destroy");
+    this.aG_("destroy");
   }
 };
 
 componentProto.elId = componentProto.getElId;
-componentProto.aI_ = componentProto.update;
-componentProto.aJ_ = componentProto.destroy;
+componentProto.aJ_ = componentProto.update;
+componentProto.aK_ = componentProto.destroy;
 
 // Add all of the following DOM methods to Component.prototype:
 // - appendTo(referenceEl)
@@ -604,7 +604,7 @@ componentProto.aJ_ = componentProto.destroy;
 // - insertAfter(referenceEl)
 // - prependTo(referenceEl)
 domInsert(componentProto, function getEl(component) {
-  return component.aC_();
+  return component.aD_();
 }, function afterInsert(component) {
   return component;
 });