marko 5.35.6 → 5.35.8

package/dist/runtime/components/Component.js

@@ -1,13 +1,13 @@
 "use strict";
-/* jshint newcap:false */
 
+// eslint-disable-next-line no-constant-binary-expression
 
 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._k_;
-var destroyNodeRecursive = componentsUtil._Q_;
+var componentLookup = componentsUtil._l_;
+var destroyNodeRecursive = componentsUtil._R_;
 var defaultCreateOut = require("../createOut");
 var domInsert = require("../dom-insert");
 var RenderResult = require("../RenderResult");
@@ -17,8 +17,8 @@ require("./ComponentsContext").S_;
 var domData = require("./dom-data");
 var eventDelegation = require("./event-delegation");
 var updateManager = require("./update-manager");
-var componentsByDOMNode = domData._o_;
-var keyedElementsByComponentId = domData._n_;
+var componentsByDOMNode = domData._p_;
+var keyedElementsByComponentId = domData._o_;
 var CONTEXT_KEY = "__subtree_context__";
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -65,7 +65,7 @@ extraArgs)
     args = extraArgs.concat(args);
   }
 
-  var targetComponent = componentLookup[component.W_];
+  var targetComponent = componentLookup[component.X_];
   var targetMethod =
   typeof targetMethodName === "function" ?
   targetMethodName :
@@ -127,8 +127,8 @@ function processUpdateHandlers(component, stateChanges, oldState) {
       handlerMethod.call(component, newValue, oldValue);
     });
 
-    component._x_();
-    component._s_();
+    component._y_();
+    component._t_();
   }
 
   return true;
@@ -169,20 +169,20 @@ function Component(id) {
   EventEmitter.call(this);
   this.id = id;
   this.z_ = null;
-  this._D_ = null;
-  this.ah_ = null;
-  this._v_ = 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._E_ = null;
   this.ai_ = null;
+  this._w_ = null;
+  this.Y_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
+  this.W_ = null;
+  this.X_ = null;
+  this.aj_ = null;
   this.O_ = undefined;
-  this._w_ = false;
-  this.aj_ = undefined;
+  this._x_ = false;
+  this.ak_ = undefined;
   this.I_ = false;
-  this._a_ = false;
-  this.ak_ = false;
+  this._b_ = false;
   this.al_ = false;
+  this.am_ = false;
   this.B_ = undefined;
 
   var ssrKeyedElements = keyedElementsByComponentId[id];
@@ -204,8 +204,8 @@ Component.prototype = componentProto = {
     }
 
     var subscriptions =
-    this.ah_ || (
-    this.ah_ = new SubscriptionTracker());
+    this.ai_ || (
+    this.ai_ = new SubscriptionTracker());
 
     var subscribeToOptions = target.x_ ?
     COMPONENT_SUBSCRIBE_TO_OPTIONS :
@@ -215,7 +215,7 @@ Component.prototype = componentProto = {
   },
 
   emit: function (eventType) {
-    var customEvents = this.V_;
+    var customEvents = this.W_;
     var target;
 
     if (customEvents && (target = customEvents[eventType])) {
@@ -304,16 +304,16 @@ Component.prototype = componentProto = {
       return;
     }
 
-    var root = this._D_;
+    var root = this._E_;
 
-    this._M_();
+    this._N_();
 
     var nodes = root.nodes;
 
     nodes.forEach(function (node) {
       destroyNodeRecursive(node);
 
-      if (eventDelegation.am_(node) !== false) {
+      if (eventDelegation.an_(node) !== false) {
         node.parentNode.removeChild(node);
       }
     });
@@ -324,25 +324,25 @@ Component.prototype = componentProto = {
     this.K_ = {};
   },
 
-  _M_: function () {
+  _N_: function () {
     if (this.I_) {
       return;
     }
 
-    this.an_();
+    this.ao_();
     this.I_ = true;
 
-    componentsByDOMNode.set(this._D_, undefined);
+    componentsByDOMNode.set(this._E_, undefined);
 
-    this._D_ = null;
+    this._E_ = null;
 
     // Unsubscribe from all DOM events
-    this._u_();
+    this._v_();
 
-    var subscriptions = this.ah_;
+    var subscriptions = this.ai_;
     if (subscriptions) {
       subscriptions.removeAllListeners();
-      this.ah_ = null;
+      this.ai_ = null;
     }
   },
 
@@ -362,10 +362,10 @@ Component.prototype = componentProto = {
       state = this.z_ = new this.P_(this);
     }
 
-    state.ao_(newState || {});
+    state.ap_(newState || {});
 
-    if (state.ak_) {
-      this.ap_();
+    if (state.al_) {
+      this.aq_();
     }
 
     if (!newState) {
@@ -383,11 +383,11 @@ Component.prototype = componentProto = {
       var newState = name;
       for (var k in newState) {
         if (hasOwnProperty.call(newState, k)) {
-          state.aq_(k, newState[k], true /* ensure:true */);
+          state.ar_(k, newState[k], true /* ensure:true */);
         }
       }
     } else {
-      state.aq_(name, value, true /* ensure:true */);
+      state.ar_(name, value, true /* ensure:true */);
     }
   },
 
@@ -398,7 +398,7 @@ Component.prototype = componentProto = {
       value = state[name];
     }
 
-    state.aq_(
+    state.ar_(
       name,
       value,
       true /* ensure:true */,
@@ -407,46 +407,46 @@ Component.prototype = componentProto = {
   },
 
   replaceState: function (newState) {
-    this.z_.ao_(newState);
+    this.z_.ap_(newState);
   },
 
   get input() {
     return this.O_;
   },
   set input(newInput) {
-    if (this.al_) {
+    if (this.am_) {
       this.O_ = newInput;
     } else {
-      this._h_(newInput);
+      this._i_(newInput);
     }
   },
 
-  _h_: function (newInput, onInput, out) {
+  _i_: function (newInput, onInput, out) {
     onInput = onInput || this.onInput;
     var updatedInput;
 
     var oldInput = this.O_;
     this.O_ = undefined;
-    this.ar_ = out && out[CONTEXT_KEY] || this.ar_;
+    this.as_ = out && out[CONTEXT_KEY] || this.as_;
 
     if (onInput) {
       // We need to set a flag to preview `this.input = foo` inside
       // onInput causing infinite recursion
-      this.al_ = true;
+      this.am_ = true;
       updatedInput = onInput.call(this, newInput || {}, out);
-      this.al_ = false;
+      this.am_ = false;
     }
 
-    newInput = this.ai_ = updatedInput || newInput;
+    newInput = this.aj_ = updatedInput || newInput;
 
-    if (this.ak_ = checkInputChanged(this, oldInput, newInput)) {
-      this.ap_();
+    if (this.al_ = checkInputChanged(this, oldInput, newInput)) {
+      this.aq_();
     }
 
     if (this.O_ === undefined) {
       this.O_ = newInput;
       if (newInput && newInput.$global) {
-        this.aj_ = newInput.$global;
+        this.ak_ = newInput.$global;
       }
     }
 
@@ -454,57 +454,57 @@ Component.prototype = componentProto = {
   },
 
   forceUpdate: function () {
-    this.ak_ = true;
-    this.ap_();
+    this.al_ = true;
+    this.aq_();
   },
 
-  ap_: function () {
-    if (!this._a_) {
-      this._a_ = true;
-      updateManager.as_(this);
+  aq_: function () {
+    if (!this._b_) {
+      this._b_ = true;
+      updateManager.at_(this);
     }
   },
 
   update: function () {
-    if (this.I_ === true || this.at_ === false) {
+    if (this.I_ === true || this.au_ === false) {
       return;
     }
 
     var input = this.O_;
     var state = this.z_;
 
-    if (this.ak_ === false && state !== null && state.ak_ === true) {
-      if (processUpdateHandlers(this, state.au_, state.av_, state)) {
-        state.ak_ = false;
+    if (this.al_ === false && state !== null && state.al_ === true) {
+      if (processUpdateHandlers(this, state.av_, state.aw_, state)) {
+        state.al_ = false;
       }
     }
 
-    if (this.at_ === true) {
+    if (this.au_ === true) {
       // The UI component is still dirty after process state handlers
       // then we should rerender
 
       if (this.shouldUpdate(input, state) !== false) {
-        this.aw_();
+        this.ax_();
       }
     }
 
-    this._s_();
+    this._t_();
   },
 
-  get at_() {
+  get au_() {
     return (
-      this.ak_ === true ||
-      this.z_ !== null && this.z_.ak_ === true);
+      this.al_ === true ||
+      this.z_ !== null && this.z_.al_ === true);
 
   },
 
-  _s_: function () {
-    this.ak_ = false;
-    this._a_ = false;
-    this.ai_ = null;
+  _t_: function () {
+    this.al_ = false;
+    this._b_ = false;
+    this.aj_ = null;
     var state = this.z_;
     if (state) {
-      state._s_();
+      state._t_();
     }
   },
 
@@ -512,7 +512,8 @@ Component.prototype = componentProto = {
     return true;
   },
 
-  aw_: function () {
+  ax_: function () {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
     var self = this;
     var renderer = self.Q_;
 
@@ -520,64 +521,64 @@ Component.prototype = componentProto = {
       throw TypeError();
     }
 
-    var input = this.ai_ || this.O_;
+    var input = this.aj_ || this.O_;
 
-    updateManager.ax_(function () {
-      self._E_(input, false).afterInsert(self.B_);
+    updateManager.ay_(function () {
+      self._F_(input, false).afterInsert(self.B_);
     });
 
-    this._s_();
+    this._t_();
   },
 
-  _E_: function (input, isHydrate) {
+  _F_: function (input, isHydrate) {
     var host = this.B_;
-    var globalData = this.aj_;
-    var rootNode = this._D_;
+    var globalData = this.ak_;
+    var rootNode = this._E_;
     var renderer = this.Q_;
     var createOut = renderer.createOut || defaultCreateOut;
     var out = createOut(globalData);
     out.sync();
     out.B_ = this.B_;
-    out[CONTEXT_KEY] = this.ar_;
+    out[CONTEXT_KEY] = this.as_;
 
     var componentsContext = getComponentsContext(out);
     var globalComponentsContext = componentsContext.p_;
-    globalComponentsContext.ay_ = this;
-    globalComponentsContext._Y_ = isHydrate;
+    globalComponentsContext.az_ = this;
+    globalComponentsContext._Z_ = isHydrate;
 
     renderer(input, out);
 
     var result = new RenderResult(out);
 
-    var targetNode = out.ag_().az_;
+    var targetNode = out.ah_().aA_;
 
     morphdom(rootNode, targetNode, host, componentsContext);
 
     return result;
   },
 
-  aA_: function () {
-    var root = this._D_;
+  aB_: function () {
+    var root = this._E_;
     root.remove();
     return root;
   },
 
-  _u_: function () {
-    var eventListenerHandles = this._v_;
+  _v_: function () {
+    var eventListenerHandles = this._w_;
     if (eventListenerHandles) {
       eventListenerHandles.forEach(removeListener);
-      this._v_ = null;
+      this._w_ = null;
     }
   },
 
-  get aB_() {
+  get aC_() {
     var state = this.z_;
     return state && state.A_;
   },
 
-  aC_: function (customEvents, scope) {
-    var finalCustomEvents = this.V_ = {};
-    this.W_ = scope;
+  aD_: function (customEvents, scope) {
+    var finalCustomEvents = this.W_ = {};
+    this.X_ = scope;
 
     customEvents.forEach(function (customEvent) {
       var eventType = customEvent[0];
@@ -592,7 +593,7 @@ Component.prototype = componentProto = {
   },
 
   get el() {
-    return walkFragments(this._D_);
+    return walkFragments(this._E_);
   },
 
   get els() {
@@ -602,43 +603,43 @@ Component.prototype = componentProto = {
 
 
 
-    return (this._D_ ? this._D_.nodes : []).filter(
+    return (this._E_ ? this._E_.nodes : []).filter(
       function (el) {
         return el.nodeType === ELEMENT_NODE;
       }
     );
   },
 
-  aD_: emit,
-  aE_(input, out) {
+  aE_: emit,
+  aF_(input, out) {
     this.onCreate && this.onCreate(input, out);
-    this.aD_("create", input, out);
+    this.aE_("create", input, out);
   },
 
-  aF_(out) {
+  aG_(out) {
     this.onRender && this.onRender(out);
-    this.aD_("render", out);
+    this.aE_("render", out);
   },
 
-  _x_() {
+  _y_() {
     this.onUpdate && this.onUpdate();
-    this.aD_("update");
+    this.aE_("update");
   },
 
-  _y_() {
+  _z_() {
     this.onMount && this.onMount();
-    this.aD_("mount");
+    this.aE_("mount");
   },
 
-  an_() {
+  ao_() {
     this.onDestroy && this.onDestroy();
-    this.aD_("destroy");
+    this.aE_("destroy");
   }
 };
 
 componentProto.elId = componentProto.getElId;
-componentProto.aG_ = componentProto.update;
-componentProto.aH_ = componentProto.destroy;
+componentProto.aH_ = componentProto.update;
+componentProto.aI_ = componentProto.destroy;
 
 // Add all of the following DOM methods to Component.prototype:
 // - appendTo(referenceEl)
@@ -650,7 +651,7 @@ componentProto.aH_ = componentProto.destroy;
 domInsert(
   componentProto,
   function getEl(component) {
-    return component.aA_();
+    return component.aB_();
   },
   function afterInsert(component) {
     return component;

package/dist/runtime/components/ComponentDef.js

@@ -1,11 +1,12 @@
 "use strict";
+// eslint-disable-next-line no-constant-binary-expression
 
 var extend = require("raptor-util/extend");
-var w10Noop = require("warp10/constants").NOOP;
 var componentUtil = require("@internal/components-util");
-var attachBubblingEvent = componentUtil._S_;
+var w10NOOP = require("../helpers/serialize-noop").aJ_;
+var attachBubblingEvent = componentUtil._T_;
 var addDelegatedEventHandler =
-require("./event-delegation")._r_;
+require("./event-delegation")._s_;
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
 
@@ -20,25 +21,25 @@ var FLAG_OLD_HYDRATE_NO_CREATE = 8;
  * later (after the rendered HTML has been added to the DOM)
  */
 function ComponentDef(component, componentId, componentsContext) {
-  this.aI_ = componentsContext; // The AsyncWriter that this component is associated with
+  this.aK_ = componentsContext; // The AsyncWriter that this component is associated with
   this.s_ = component;
   this.id = componentId;
 
-  this._b_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this._c_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._t_ = false;
+  this._u_ = false;
 
   this.t_ = false;
   this.u_ = 0;
 
-  this.aJ_ = 0; // The unique integer to use for the next scoped ID
-  this.aK_ = null;
+  this.aL_ = 0; // The unique integer to use for the next scoped ID
+  this.aM_ = null;
 }
 
 ComponentDef.prototype = {
-  aL_: function (key) {
+  aN_: function (key) {
     return (
-    this.aK_ || (this.aK_ = new KeySequence())).aL_(
+    this.aM_ || (this.aM_ = new KeySequence())).aN_(
       key);
   },
 
@@ -72,8 +73,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  aM_: function () {
-    return this.id + "-c" + this.aJ_++;
+  aO_: function () {
+    return this.id + "-c" + this.aL_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -81,14 +82,14 @@ ComponentDef.prototype = {
     return attachBubblingEvent(this, handlerMethodName, isOnce, extraArgs);
   },
 
-  get _p_() {
-    return this.s_._p_;
+  get _q_() {
+    return this.s_._q_;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype.aL_;
+ComponentDef.prototype.nk = ComponentDef.prototype.aN_;
 
-ComponentDef._C_ = function (o, types, global, registry) {
+ComponentDef._D_ = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
@@ -98,19 +99,20 @@ ComponentDef._C_ = function (o, types, global, registry) {
   var componentProps = extra.w || EMPTY_OBJECT;
   var flags = extra.f;
   var isLegacy = flags & FLAG_IS_LEGACY;
-  var renderBody = flags & FLAG_HAS_RENDER_BODY ? w10Noop : extra.r;
+  var renderBody = flags & FLAG_HAS_RENDER_BODY ? w10NOOP : extra.r;
 
   var component =
   typeName /* legacy */ &&
-  registry._F_(typeName, id, isLegacy);
+  registry._G_(typeName, id, isLegacy);
 
   // Prevent newly created component from being queued for update since we area
   // just building it from the server info
-  component._a_ = true;
+  component._b_ = true;
+  component.ak_ = global;
 
   if (isLegacy) {
     component.widgetConfig = componentProps;
-    component.Y_ = renderBody;
+    component.Z_ = renderBody;
   } else if (renderBody) {
     (input || (input = {})).renderBody = renderBody;
   }
@@ -147,21 +149,19 @@ ComponentDef._C_ = function (o, types, global, registry) {
   component.O_ = input;
 
   if (extra.b) {
-    component.X_ = extra.b;
+    component.Y_ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component.aC_(customEvents, scope);
+    component.aD_(customEvents, scope);
   }
 
-  component.aj_ = global;
-
   return {
     id: id,
     s_: component,
-    _b_: extra.d,
+    _c_: extra.d,
     u_: extra.f || 0
   };
 };

package/dist/runtime/components/ComponentsContext.js

@@ -11,9 +11,9 @@ function ComponentsContext(out, parentComponentsContext) {
 
     var nestedContextsForParent;
     if (
-    !(nestedContextsForParent = parentComponentsContext._c_))
+    !(nestedContextsForParent = parentComponentsContext._d_))
     {
-      nestedContextsForParent = parentComponentsContext._c_ = [];
+      nestedContextsForParent = parentComponentsContext._d_ = [];
     }
 
     nestedContextsForParent.push(this);
@@ -29,18 +29,18 @@ function ComponentsContext(out, parentComponentsContext) {
   this.b_ = [];
   this.r_ = out;
   this.o_ = componentDef;
-  this._c_ = undefined;
+  this._d_ = undefined;
   this.v_ =
   parentComponentsContext && parentComponentsContext.v_;
 }
 
 ComponentsContext.prototype = {
-  ae_: function (host) {
+  af_: function (host) {
     var componentDefs = this.b_;
 
-    ComponentsContext._H_(componentDefs, host);
+    ComponentsContext._I_(componentDefs, host);
 
-    this.r_.emit("aN_");
+    this.r_.emit("aP_");
 
     // Reset things stored in global since global is retained for
     // future renders

package/dist/runtime/components/GlobalComponentsContext.js

@@ -1,10 +1,10 @@
 "use strict";var nextComponentIdProvider =
-require("@internal/components-util")._R_;
+require("@internal/components-util")._S_;
 
 function GlobalComponentsContext(out) {
   this.q_ = {};
-  this.ay_ = undefined;
-  this.aM_ = nextComponentIdProvider(out);
+  this.az_ = undefined;
+  this.aO_ = nextComponentIdProvider(out);
 }
 
 module.exports = GlobalComponentsContext;

package/dist/runtime/components/KeySequence.js

@@ -1,9 +1,9 @@
 "use strict";function KeySequence() {
-  this.aO_ = Object.create(null);
+  this.aQ_ = Object.create(null);
 }
 
-KeySequence.prototype.aL_ = function (key) {
-  var lookup = this.aO_;
+KeySequence.prototype.aN_ = function (key) {
+  var lookup = this.aQ_;
 
   if (lookup[key]) {
     return key + "_" + lookup[key]++;