marko 5.33.9 → 5.33.11

package/dist/runtime/components/Component.js

@@ -6,19 +6,19 @@ var EventEmitter = require("events-light");
 var SubscriptionTracker = require("listener-tracker");
 var inherit = require("raptor-util/inherit");
 var componentsUtil = require("@internal/components-util");
-var componentLookup = componentsUtil._i_;
-var destroyNodeRecursive = componentsUtil._O_;
+var componentLookup = componentsUtil._k_;
+var destroyNodeRecursive = componentsUtil._Q_;
 var defaultCreateOut = require("../createOut");
 var domInsert = require("../dom-insert");
 var RenderResult = require("../RenderResult");
 var morphdom = require("../vdom/morphdom");
 var getComponentsContext =
-require("./ComponentsContext").R_;
+require("./ComponentsContext").S_;
 var domData = require("./dom-data");
 var eventDelegation = require("./event-delegation");
 var updateManager = require("./update-manager");
-var componentsByDOMNode = domData._l_;
-var keyedElementsByComponentId = domData._k_;
+var componentsByDOMNode = domData._n_;
+var keyedElementsByComponentId = domData._m_;
 var CONTEXT_KEY = "__subtree_context__";
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -65,7 +65,7 @@ extraArgs)
     args = extraArgs.concat(args);
   }
 
-  var targetComponent = componentLookup[component.V_];
+  var targetComponent = componentLookup[component.W_];
   var targetMethod =
   typeof targetMethodName === "function" ?
   targetMethodName :
@@ -127,8 +127,8 @@ function processUpdateHandlers(component, stateChanges, oldState) {
       handlerMethod.call(component, newValue, oldValue);
     });
 
-    component._u_();
-    component._p_();
+    component._w_();
+    component._r_();
   }
 
   return true;
@@ -168,35 +168,35 @@ var componentProto;
 function Component(id) {
   EventEmitter.call(this);
   this.id = id;
-  this.y_ = null;
-  this._A_ = null;
-  this.ag_ = null;
-  this._s_ = null;
-  this.W_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
-  this.U_ = null;
-  this.V_ = null;
+  this.z_ = null;
+  this._C_ = null;
   this.ah_ = null;
-  this.N_ = undefined;
-  this._t_ = false;
-  this.ai_ = undefined;
-  this.H_ = false;
-  this.___ = false;
-  this.aj_ = false;
+  this._u_ = null;
+  this.X_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
+  this.V_ = null;
+  this.W_ = null;
+  this.ai_ = null;
+  this.O_ = undefined;
+  this._v_ = false;
+  this.aj_ = undefined;
+  this.I_ = false;
+  this._a_ = false;
   this.ak_ = false;
-  this.A_ = undefined;
+  this.al_ = false;
+  this.B_ = undefined;
 
   var ssrKeyedElements = keyedElementsByComponentId[id];
 
   if (ssrKeyedElements) {
-    this.J_ = ssrKeyedElements;
+    this.K_ = ssrKeyedElements;
     delete keyedElementsByComponentId[id];
   } else {
-    this.J_ = {};
+    this.K_ = {};
   }
 }
 
 Component.prototype = componentProto = {
-  w_: true,
+  x_: true,
 
   subscribeTo: function (target) {
     if (!target) {
@@ -204,10 +204,10 @@ Component.prototype = componentProto = {
     }
 
     var subscriptions =
-    this.ag_ || (
-    this.ag_ = new SubscriptionTracker());
+    this.ah_ || (
+    this.ah_ = new SubscriptionTracker());
 
-    var subscribeToOptions = target.w_ ?
+    var subscribeToOptions = target.x_ ?
     COMPONENT_SUBSCRIBE_TO_OPTIONS :
     NON_COMPONENT_SUBSCRIBE_TO_OPTIONS;
 
@@ -215,7 +215,7 @@ Component.prototype = componentProto = {
   },
 
   emit: function (eventType) {
-    var customEvents = this.U_;
+    var customEvents = this.V_;
     var target;
 
     if (customEvents && (target = customEvents[eventType])) {
@@ -247,7 +247,7 @@ Component.prototype = componentProto = {
   getEl: function (key, index) {
     if (key) {
       var resolvedKey = resolveKeyHelper(key, index);
-      var keyedElement = this.J_["@" + resolvedKey];
+      var keyedElement = this.K_["@" + resolvedKey];
       if (keyedElement && keyedElement.nodeType === 12 /** FRAGMENT_NODE */) {
         // eslint-disable-next-line no-constant-condition
 
@@ -277,7 +277,7 @@ Component.prototype = componentProto = {
     return els;
   },
   getComponent: function (key, index) {
-    var rootNode = this.J_["@" + resolveKeyHelper(key, index)];
+    var rootNode = this.K_["@" + resolveKeyHelper(key, index)];
     if (/\[\]$/.test(key)) {
       // eslint-disable-next-line no-constant-condition
 
@@ -290,7 +290,7 @@ Component.prototype = componentProto = {
     return rootNode && componentsByDOMNode.get(rootNode);
   },
   getComponents: function (key) {
-    var lookup = this.J_["@" + key + "[]"];
+    var lookup = this.K_["@" + key + "[]"];
     return lookup ?
     Object.keys(lookup).
     map(function (key) {
@@ -300,20 +300,20 @@ Component.prototype = componentProto = {
     [];
   },
   destroy: function () {
-    if (this.H_) {
+    if (this.I_) {
       return;
     }
 
-    var root = this._A_;
+    var root = this._C_;
 
-    this._K_();
+    this._M_();
 
     var nodes = root.nodes;
 
     nodes.forEach(function (node) {
       destroyNodeRecursive(node);
 
-      if (eventDelegation.al_(node) !== false) {
+      if (eventDelegation.am_(node) !== false) {
         node.parentNode.removeChild(node);
       }
     });
@@ -321,84 +321,84 @@ Component.prototype = componentProto = {
     root.detached = true;
 
     delete componentLookup[this.id];
-    this.J_ = {};
+    this.K_ = {};
   },
 
-  _K_: function () {
-    if (this.H_) {
+  _M_: function () {
+    if (this.I_) {
       return;
     }
 
-    this.am_();
-    this.H_ = true;
+    this.an_();
+    this.I_ = true;
 
-    componentsByDOMNode.set(this._A_, undefined);
+    componentsByDOMNode.set(this._C_, undefined);
 
-    this._A_ = null;
+    this._C_ = null;
 
     // Unsubscribe from all DOM events
-    this._r_();
+    this._t_();
 
-    var subscriptions = this.ag_;
+    var subscriptions = this.ah_;
     if (subscriptions) {
       subscriptions.removeAllListeners();
-      this.ag_ = null;
+      this.ah_ = null;
     }
   },
 
   isDestroyed: function () {
-    return this.H_;
+    return this.I_;
   },
   get state() {
-    return this.y_;
+    return this.z_;
   },
   set state(newState) {
-    var state = this.y_;
+    var state = this.z_;
     if (!state && !newState) {
       return;
     }
 
     if (!state) {
-      state = this.y_ = new this.O_(this);
+      state = this.z_ = new this.P_(this);
     }
 
-    state.an_(newState || {});
+    state.ao_(newState || {});
 
-    if (state.aj_) {
-      this.ao_();
+    if (state.ak_) {
+      this.ap_();
     }
 
     if (!newState) {
-      this.y_ = null;
+      this.z_ = null;
     }
   },
   setState: function (name, value) {
-    var state = this.y_;
+    var state = this.z_;
 
     if (!state) {
-      state = this.y_ = new this.O_(this);
+      state = this.z_ = new this.P_(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.ap_(k, newState[k], true /* ensure:true */);
+          state.aq_(k, newState[k], true /* ensure:true */);
         }
       }
     } else {
-      state.ap_(name, value, true /* ensure:true */);
+      state.aq_(name, value, true /* ensure:true */);
     }
   },
 
   setStateDirty: function (name, value) {
-    var state = this.y_;
+    var state = this.z_;
 
     if (arguments.length == 1) {
       value = state[name];
     }
 
-    state.ap_(
+    state.aq_(
       name,
       value,
       true /* ensure:true */,
@@ -407,46 +407,46 @@ Component.prototype = componentProto = {
   },
 
   replaceState: function (newState) {
-    this.y_.an_(newState);
+    this.z_.ao_(newState);
   },
 
   get input() {
-    return this.N_;
+    return this.O_;
   },
   set input(newInput) {
-    if (this.ak_) {
-      this.N_ = newInput;
+    if (this.al_) {
+      this.O_ = newInput;
     } else {
-      this._g_(newInput);
+      this._h_(newInput);
     }
   },
 
-  _g_: function (newInput, onInput, out) {
+  _h_: function (newInput, onInput, out) {
     onInput = onInput || this.onInput;
     var updatedInput;
 
-    var oldInput = this.N_;
-    this.N_ = undefined;
-    this.aq_ = out && out[CONTEXT_KEY] || this.aq_;
+    var oldInput = this.O_;
+    this.O_ = undefined;
+    this.ar_ = out && out[CONTEXT_KEY] || this.ar_;
 
     if (onInput) {
       // We need to set a flag to preview `this.input = foo` inside
       // onInput causing infinite recursion
-      this.ak_ = true;
+      this.al_ = true;
       updatedInput = onInput.call(this, newInput || {}, out);
-      this.ak_ = false;
+      this.al_ = false;
     }
 
-    newInput = this.ah_ = updatedInput || newInput;
+    newInput = this.ai_ = updatedInput || newInput;
 
-    if (this.aj_ = checkInputChanged(this, oldInput, newInput)) {
-      this.ao_();
+    if (this.ak_ = checkInputChanged(this, oldInput, newInput)) {
+      this.ap_();
     }
 
-    if (this.N_ === undefined) {
-      this.N_ = newInput;
+    if (this.O_ === undefined) {
+      this.O_ = newInput;
       if (newInput && newInput.$global) {
-        this.ai_ = newInput.$global;
+        this.aj_ = newInput.$global;
       }
     }
 
@@ -454,57 +454,57 @@ Component.prototype = componentProto = {
   },
 
   forceUpdate: function () {
-    this.aj_ = true;
-    this.ao_();
+    this.ak_ = true;
+    this.ap_();
   },
 
-  ao_: function () {
-    if (!this.___) {
-      this.___ = true;
-      updateManager.ar_(this);
+  ap_: function () {
+    if (!this._a_) {
+      this._a_ = true;
+      updateManager.as_(this);
     }
   },
 
   update: function () {
-    if (this.H_ === true || this.as_ === false) {
+    if (this.I_ === true || this.at_ === false) {
       return;
     }
 
-    var input = this.N_;
-    var state = this.y_;
+    var input = this.O_;
+    var state = this.z_;
 
-    if (this.aj_ === false && state !== null && state.aj_ === true) {
-      if (processUpdateHandlers(this, state.at_, state.au_, state)) {
-        state.aj_ = false;
+    if (this.ak_ === false && state !== null && state.ak_ === true) {
+      if (processUpdateHandlers(this, state.au_, state.av_, state)) {
+        state.ak_ = false;
       }
     }
 
-    if (this.as_ === true) {
+    if (this.at_ === true) {
       // The UI component is still dirty after process state handlers
       // then we should rerender
 
       if (this.shouldUpdate(input, state) !== false) {
-        this.av_();
+        this.aw_();
       }
     }
 
-    this._p_();
+    this._r_();
   },
 
-  get as_() {
+  get at_() {
     return (
-      this.aj_ === true ||
-      this.y_ !== null && this.y_.aj_ === true);
+      this.ak_ === true ||
+      this.z_ !== null && this.z_.ak_ === true);
 
   },
 
-  _p_: function () {
-    this.aj_ = false;
-    this.___ = false;
-    this.ah_ = null;
-    var state = this.y_;
+  _r_: function () {
+    this.ak_ = false;
+    this._a_ = false;
+    this.ai_ = null;
+    var state = this.z_;
     if (state) {
-      state._p_();
+      state._r_();
     }
   },
 
@@ -512,72 +512,72 @@ Component.prototype = componentProto = {
     return true;
   },
 
-  av_: function () {
+  aw_: function () {
     var self = this;
-    var renderer = self.P_;
+    var renderer = self.Q_;
 
     if (!renderer) {
       throw TypeError();
     }
 
-    var input = this.ah_ || this.N_;
+    var input = this.ai_ || this.O_;
 
-    updateManager.aw_(function () {
-      self._B_(input, false).afterInsert(self.A_);
+    updateManager.ax_(function () {
+      self._D_(input, false).afterInsert(self.B_);
     });
 
-    this._p_();
+    this._r_();
   },
 
-  _B_: function (input, isHydrate) {
-    var host = this.A_;
-    var globalData = this.ai_;
-    var rootNode = this._A_;
-    var renderer = this.P_;
+  _D_: function (input, isHydrate) {
+    var host = this.B_;
+    var globalData = this.aj_;
+    var rootNode = this._C_;
+    var renderer = this.Q_;
     var createOut = renderer.createOut || defaultCreateOut;
     var out = createOut(globalData);
     out.sync();
-    out.A_ = this.A_;
-    out[CONTEXT_KEY] = this.aq_;
+    out.B_ = this.B_;
+    out[CONTEXT_KEY] = this.ar_;
 
     var componentsContext = getComponentsContext(out);
-    var globalComponentsContext = componentsContext.o_;
-    globalComponentsContext.ax_ = this;
-    globalComponentsContext._W_ = isHydrate;
+    var globalComponentsContext = componentsContext.p_;
+    globalComponentsContext.ay_ = this;
+    globalComponentsContext._Y_ = isHydrate;
 
     renderer(input, out);
 
     var result = new RenderResult(out);
 
-    var targetNode = out.af_().ay_;
+    var targetNode = out.ag_().az_;
 
     morphdom(rootNode, targetNode, host, componentsContext);
 
     return result;
   },
 
-  az_: function () {
-    var root = this._A_;
+  aA_: function () {
+    var root = this._C_;
     root.remove();
     return root;
   },
 
-  _r_: function () {
-    var eventListenerHandles = this._s_;
+  _t_: function () {
+    var eventListenerHandles = this._u_;
     if (eventListenerHandles) {
       eventListenerHandles.forEach(removeListener);
-      this._s_ = null;
+      this._u_ = null;
     }
   },
 
-  get aA_() {
-    var state = this.y_;
-    return state && state.z_;
+  get aB_() {
+    var state = this.z_;
+    return state && state.A_;
   },
 
-  aB_: function (customEvents, scope) {
-    var finalCustomEvents = this.U_ = {};
-    this.V_ = scope;
+  aC_: function (customEvents, scope) {
+    var finalCustomEvents = this.V_ = {};
+    this.W_ = scope;
 
     customEvents.forEach(function (customEvent) {
       var eventType = customEvent[0];
@@ -592,7 +592,7 @@ Component.prototype = componentProto = {
   },
 
   get el() {
-    return walkFragments(this._A_);
+    return walkFragments(this._C_);
   },
 
   get els() {
@@ -602,43 +602,43 @@ Component.prototype = componentProto = {
 
 
 
-    return (this._A_ ? this._A_.nodes : []).filter(
+    return (this._C_ ? this._C_.nodes : []).filter(
       function (el) {
         return el.nodeType === ELEMENT_NODE;
       }
     );
   },
 
-  aC_: emit,
-  aD_(input, out) {
+  aD_: emit,
+  aE_(input, out) {
     this.onCreate && this.onCreate(input, out);
-    this.aC_("create", input, out);
+    this.aD_("create", input, out);
   },
 
-  aE_(out) {
+  aF_(out) {
     this.onRender && this.onRender(out);
-    this.aC_("render", out);
+    this.aD_("render", out);
   },
 
-  _u_() {
+  _w_() {
     this.onUpdate && this.onUpdate();
-    this.aC_("update");
+    this.aD_("update");
   },
 
-  _v_() {
+  _x_() {
     this.onMount && this.onMount();
-    this.aC_("mount");
+    this.aD_("mount");
   },
 
-  am_() {
+  an_() {
     this.onDestroy && this.onDestroy();
-    this.aC_("destroy");
+    this.aD_("destroy");
   }
 };
 
 componentProto.elId = componentProto.getElId;
-componentProto.aF_ = componentProto.update;
-componentProto.aG_ = componentProto.destroy;
+componentProto.aG_ = componentProto.update;
+componentProto.aH_ = componentProto.destroy;
 
 // Add all of the following DOM methods to Component.prototype:
 // - appendTo(referenceEl)
@@ -650,7 +650,7 @@ componentProto.aG_ = componentProto.destroy;
 domInsert(
   componentProto,
   function getEl(component) {
-    return component.az_();
+    return component.aA_();
   },
   function afterInsert(component) {
     return component;