marko 4.28.7 → 4.28.8

package/dist/runtime/components/ComponentDef.js

@@ -2,8 +2,8 @@
 
 var w10Noop = require("warp10/constants").NOOP;
 var componentUtil = require("@internal/components-util");
-var attachBubblingEvent = componentUtil._U_;
-var addDelegatedEventHandler = require("./event-delegation")._s_;
+var attachBubblingEvent = componentUtil._V_;
+var addDelegatedEventHandler = require("./event-delegation")._t_;
 var extend = require("raptor-util/extend");
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
@@ -19,24 +19,24 @@ var FLAG_OLD_HYDRATE_NO_CREATE = 8;
  * later (after the rendered HTML has been added to the DOM)
  */
 function ComponentDef(component, componentId, componentsContext) {
-  this.aK_ = componentsContext; // The AsyncWriter that this component is associated with
-  this.v_ = component;
+  this.aL_ = componentsContext; // The AsyncWriter that this component is associated with
+  this.w_ = component;
   this.id = componentId;
 
-  this._d_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this._e_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._u_ = false;
+  this._v_ = false;
 
-  this.w_ = false;
-  this.x_ = 0;
+  this.x_ = false;
+  this.y_ = 0;
 
-  this.aL_ = 0; // The unique integer to use for the next scoped ID
-  this.aM_ = null;
+  this.aM_ = 0; // The unique integer to use for the next scoped ID
+  this.aN_ = null;
 }
 
 ComponentDef.prototype = {
-  aN_: function (key) {
-    return (this.aM_ || (this.aM_ = new KeySequence())).aN_(key);
+  aO_: function (key) {
+    return (this.aN_ || (this.aN_ = new KeySequence())).aO_(key);
   },
 
   /**
@@ -64,8 +64,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  aO_: function () {
-    return this.id + "-c" + this.aL_++;
+  aP_: function () {
+    return this.id + "-c" + this.aM_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -74,13 +74,13 @@ ComponentDef.prototype = {
   },
 
   get e_() {
-    return this.v_.e_;
+    return this.w_.e_;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype.aN_;
+ComponentDef.prototype.nk = ComponentDef.prototype.aO_;
 
-ComponentDef._D_ = function (o, types, global, registry) {
+ComponentDef._E_ = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
@@ -92,15 +92,15 @@ ComponentDef._D_ = function (o, types, global, registry) {
   var isLegacy = flags & FLAG_IS_LEGACY;
   var renderBody = flags & FLAG_HAS_RENDER_BODY ? w10Noop : extra.r;
 
-  var component = typeName /* legacy */ && registry._G_(typeName, id, isLegacy);
+  var component = typeName /* legacy */ && registry._H_(typeName, id, isLegacy);
 
   // Prevent newly created component from being queued for update since we area
   // just building it from the server info
-  component._c_ = true;
+  component._d_ = true;
 
   if (isLegacy) {
     component.widgetConfig = componentProps;
-    component.___ = renderBody;
+    component._a_ = renderBody;
   } else if (renderBody) {
     (input || (input = {})).renderBody = renderBody;
   }
@@ -130,25 +130,25 @@ ComponentDef._D_ = function (o, types, global, registry) {
     }
   }
 
-  component.R_ = input;
+  component.S_ = input;
 
   if (extra.b) {
-    component.Z_ = extra.b;
+    component.___ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component.aE_(customEvents, scope);
+    component.aF_(customEvents, scope);
   }
 
-  component.am_ = global;
+  component.an_ = global;
 
   return {
     id: id,
-    v_: component,
-    _d_: extra.d,
-    x_: extra.f || 0
+    w_: component,
+    _e_: extra.d,
+    y_: extra.f || 0
   };
 };
 

package/dist/runtime/components/ComponentsContext.js

@@ -7,50 +7,50 @@ function ComponentsContext(out, parentComponentsContext) {
   var componentDef;
 
   if (parentComponentsContext) {
-    globalComponentsContext = parentComponentsContext.r_;
-    componentDef = parentComponentsContext.q_;
+    globalComponentsContext = parentComponentsContext.s_;
+    componentDef = parentComponentsContext.r_;
 
     var nestedContextsForParent;
-    if (!(nestedContextsForParent = parentComponentsContext._e_)) {
-      nestedContextsForParent = parentComponentsContext._e_ = [];
+    if (!(nestedContextsForParent = parentComponentsContext._f_)) {
+      nestedContextsForParent = parentComponentsContext._f_ = [];
     }
 
     nestedContextsForParent.push(this);
   } else {
-    globalComponentsContext = out.global.t_;
+    globalComponentsContext = out.global.u_;
     if (globalComponentsContext === undefined) {
-      out.global.t_ = globalComponentsContext = new GlobalComponentsContext(out);
+      out.global.u_ = globalComponentsContext = new GlobalComponentsContext(out);
     }
   }
 
-  this.r_ = globalComponentsContext;
-  this.t_ = [];
-  this.u_ = out;
-  this.q_ = componentDef;
-  this._e_ = undefined;
-  this.y_ = parentComponentsContext && parentComponentsContext.y_;
+  this.s_ = globalComponentsContext;
+  this.u_ = [];
+  this.v_ = out;
+  this.r_ = componentDef;
+  this._f_ = undefined;
+  this.z_ = parentComponentsContext && parentComponentsContext.z_;
 }
 
 ComponentsContext.prototype = {
-  ah_: function (host) {
-    var componentDefs = this.t_;
+  ai_: function (host) {
+    var componentDefs = this.u_;
 
-    ComponentsContext._I_(componentDefs, host);
+    ComponentsContext._J_(componentDefs, host);
 
-    this.u_.emit("aP_");
+    this.v_.emit("aQ_");
 
     // Reset things stored in global since global is retained for
     // future renders
-    this.u_.global.t_ = undefined;
+    this.v_.global.u_ = undefined;
 
     return componentDefs;
   }
 };
 
 function getComponentsContext(out) {
-  return out.t_ || (out.t_ = new ComponentsContext(out));
+  return out.u_ || (out.u_ = new ComponentsContext(out));
 }
 
 module.exports = exports = ComponentsContext;
 
-exports.U_ = getComponentsContext;
+exports.V_ = getComponentsContext;

package/dist/runtime/components/GlobalComponentsContext.js

@@ -1,9 +1,9 @@
-var nextComponentIdProvider = require("@internal/components-util")._T_;
+var nextComponentIdProvider = require("@internal/components-util")._U_;
 
 function GlobalComponentsContext(out) {
-  this.s_ = {};
-  this.aB_ = undefined;
-  this.aO_ = nextComponentIdProvider(out);
+  this.t_ = {};
+  this.aC_ = undefined;
+  this.aP_ = nextComponentIdProvider(out);
 }
 
 module.exports = GlobalComponentsContext;

package/dist/runtime/components/KeySequence.js

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

package/dist/runtime/components/ServerComponent.js

@@ -3,38 +3,38 @@
 class ServerComponent {
   constructor(id, input, out, typeName, customEvents, scope) {
     this.id = id;
-    this.X_ = customEvents;
-    this.Y_ = scope;
+    this.Y_ = customEvents;
+    this.Z_ = scope;
     this.typeName = typeName;
-    this.Z_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
-    this._a_ = 0;
+    this.___ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
+    this._b_ = 0;
 
     this.onCreate(input, out);
-    this._b_ = this.onInput(input, out) || input;
-    if (this.R_ === undefined) {
-      this.R_ = this._b_;
+    this._c_ = this.onInput(input, out) || input;
+    if (this.S_ === undefined) {
+      this.S_ = this._c_;
     }
     this.onRender(out);
   }
 
   set input(newInput) {
-    this.R_ = newInput;
+    this.S_ = newInput;
   }
 
   get input() {
-    return this.R_;
+    return this.S_;
   }
 
   set state(newState) {
-    this.C_ = newState;
+    this.D_ = newState;
   }
 
   get state() {
-    return this.C_;
+    return this.D_;
   }
 
-  get aD_() {
-    return this.C_;
+  get aE_() {
+    return this.D_;
   }
 
   elId(nestedId) {

package/dist/runtime/components/State.js

@@ -5,83 +5,83 @@ function ensure(state, propertyName) {
   if (!(propertyName in proto)) {
     Object.defineProperty(proto, propertyName, {
       get: function () {
-        return this.D_[propertyName];
+        return this.E_[propertyName];
       },
       set: function (value) {
-        this.at_(propertyName, value, false /* ensure:false */);
+        this.au_(propertyName, value, false /* ensure:false */);
       }
     });
   }
 }
 
 function State(component) {
-  this.v_ = component;
-  this.D_ = {};
+  this.w_ = component;
+  this.E_ = {};
 
-  this.an_ = false;
+  this.ao_ = false;
+  this.az_ = null;
   this.ay_ = null;
-  this.ax_ = null;
-  this.aR_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
+  this.aS_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
 
   Object.seal(this);
 }
 
 State.prototype = {
-  _t_: function () {
+  _u_: function () {
     var self = this;
 
-    self.an_ = false;
+    self.ao_ = false;
+    self.az_ = null;
     self.ay_ = null;
-    self.ax_ = null;
-    self.aR_ = null;
+    self.aS_ = null;
   },
 
-  ar_: function (newState) {
+  as_: function (newState) {
     var state = this;
     var key;
 
-    var rawState = this.D_;
+    var rawState = this.E_;
 
     for (key in rawState) {
       if (!(key in newState)) {
-        state.at_(key, undefined, false /* ensure:false */
+        state.au_(key, undefined, false /* ensure:false */
         , false /* forceDirty:false */
         );
       }
     }
 
     for (key in newState) {
-      state.at_(key, newState[key], true /* ensure:true */
+      state.au_(key, newState[key], true /* ensure:true */
       , false /* forceDirty:false */
       );
     }
   },
-  at_: function (name, value, shouldEnsure, forceDirty) {
-    var rawState = this.D_;
+  au_: function (name, value, shouldEnsure, forceDirty) {
+    var rawState = this.E_;
 
     if (shouldEnsure) {
       ensure(this, name);
     }
 
     if (forceDirty) {
-      var forcedDirtyState = this.aR_ || (this.aR_ = {});
+      var forcedDirtyState = this.aS_ || (this.aS_ = {});
       forcedDirtyState[name] = true;
     } else if (rawState[name] === value) {
       return;
     }
 
-    if (!this.an_) {
+    if (!this.ao_) {
       // This is the first time we are modifying the component state
       // so introduce some properties to do some tracking of
       // changes to the state
-      this.an_ = true; // Mark the component state as dirty (i.e. modified)
-      this.ay_ = rawState;
-      this.D_ = rawState = extend({}, rawState);
-      this.ax_ = {};
-      this.v_.as_();
+      this.ao_ = true; // Mark the component state as dirty (i.e. modified)
+      this.az_ = rawState;
+      this.E_ = rawState = extend({}, rawState);
+      this.ay_ = {};
+      this.w_.at_();
     }
 
-    this.ax_[name] = value;
+    this.ay_[name] = value;
 
     if (value === undefined) {
       // Don't store state properties with an undefined or null value
@@ -92,7 +92,7 @@ State.prototype = {
     }
   },
   toJSON: function () {
-    return this.D_;
+    return this.E_;
   }
 };
 

package/dist/runtime/components/attach-detach.js

@@ -1,6 +1,6 @@
 var eventDelegation = require("./event-delegation");
-var delegateEvent = eventDelegation.aS_;
-var getEventFromEl = eventDelegation.aT_;
+var delegateEvent = eventDelegation.aT_;
+var getEventFromEl = eventDelegation.aU_;
 
 // var componentsUtil = require('@internal/components-util');
 // var destroyNodeRecursive = componentsUtil.___destroyNodeRecursive;
@@ -11,13 +11,13 @@ function handleNodeAttach(node, componentsContext) {
     var eventName = "onattach";
     var target = getEventFromEl(node, eventName);
     if (target) {
-      var out = componentsContext.u_;
+      var out = componentsContext.v_;
       var data = out.data;
 
-      var attachTargets = data.aU_;
+      var attachTargets = data.aV_;
       if (!attachTargets) {
-        attachTargets = data.aU_ = [];
-        out.on("aP_", function () {
+        attachTargets = data.aV_ = [];
+        out.on("aQ_", function () {
           for (var i = 0; i < attachTargets.length; i += 2) {
             var node = attachTargets[i];
             var target = attachTargets[i + 1];
@@ -56,5 +56,5 @@ function handleNodeDetach(node) {
   }
 }
 
-eventDelegation.aV_ = handleNodeAttach;
-eventDelegation.ap_ = handleNodeDetach;
+eventDelegation.aW_ = handleNodeAttach;
+eventDelegation.aq_ = handleNodeDetach;

package/dist/runtime/components/defineComponent.js

@@ -6,7 +6,7 @@ var BaseComponent = require("./Component");
 var inherit = require("raptor-util/inherit");
 
 module.exports = function defineComponent(def, renderer) {
-  if (def.A_) {
+  if (def.B_) {
     return def;
   }
 
@@ -35,7 +35,7 @@ module.exports = function defineComponent(def, renderer) {
     BaseComponent.call(this, id);
   }
 
-  if (!proto.A_) {
+  if (!proto.B_) {
     // Inherit from Component if they didn't already
     inherit(ComponentClass, BaseComponent);
   }
@@ -48,14 +48,14 @@ module.exports = function defineComponent(def, renderer) {
 
   // Set a flag on the constructor function to make it clear this is
   // a component so that we can short-circuit this work later
-  Component.A_ = true;
+  Component.B_ = true;
 
   function State(component) {
     BaseState.call(this, component);
   }
   inherit(State, BaseState);
-  proto.S_ = State;
-  proto.T_ = renderer;
+  proto.T_ = State;
+  proto.U_ = renderer;
 
   return Component;
 };

package/dist/runtime/components/dom-data.js

@@ -1,10 +1,10 @@
 var WeakMap = require("../helpers/_weak-map");
 
 module.exports = {
+  _N_: new WeakMap(),
   _M_: new WeakMap(),
+  _r_: new WeakMap(),
+  aX_: new WeakMap(),
   _L_: new WeakMap(),
-  _q_: new WeakMap(),
-  aW_: new WeakMap(),
-  _K_: new WeakMap(),
-  _p_: {}
+  _q_: {}
 };

package/dist/runtime/components/event-delegation.js

@@ -1,7 +1,7 @@
 var componentsUtil = require("@internal/components-util");
-var runtimeId = componentsUtil._Q_;
-var componentLookup = componentsUtil._n_;
-var getMarkoPropsFromEl = componentsUtil._r_;
+var runtimeId = componentsUtil._R_;
+var componentLookup = componentsUtil._o_;
+var getMarkoPropsFromEl = componentsUtil._s_;
 
 var TEXT_NODE = 3;
 
@@ -51,7 +51,7 @@ function delegateEvent(node, eventName, target, event) {
 
   if (extraArgs != null) {
     if (typeof extraArgs === "number") {
-      extraArgs = targetComponent.Z_[extraArgs];
+      extraArgs = targetComponent.___[extraArgs];
     }
   }
 
@@ -124,12 +124,12 @@ function addDelegatedEventHandlerToHost(eventType, host) {
 
 function noop() {}
 
-exports.aV_ = noop;
-exports.ap_ = noop;
-exports.aS_ = delegateEvent;
-exports.aT_ = getEventFromEl;
-exports._s_ = addDelegatedEventHandler;
-exports._A_ = function (host) {
+exports.aW_ = noop;
+exports.aq_ = noop;
+exports.aT_ = delegateEvent;
+exports.aU_ = getEventFromEl;
+exports._t_ = addDelegatedEventHandler;
+exports._B_ = function (host) {
   Object.keys(delegatedEvents).forEach(function (eventType) {
     addDelegatedEventHandlerToHost(eventType, host);
   });

package/dist/runtime/components/legacy/defineComponent-legacy.js

@@ -8,7 +8,7 @@ var defineRenderer;
 var defineWidget;
 
 module.exports = function defineComponent(def) {
-  if (def.A_) {
+  if (def.B_) {
     return def;
   }
 

package/dist/runtime/components/legacy/defineRenderer-legacy.js

@@ -1,14 +1,14 @@
 var makeRenderable = require("../../renderable");
-var getComponentsContext = require("../ComponentsContext").U_;
-var componentLookup = require("@internal/components-util")._n_;
+var getComponentsContext = require("../ComponentsContext").V_;
+var componentLookup = require("@internal/components-util")._o_;
 var modernRenderer = require("../renderer");
 var loader = require("@internal/loader");
-var resolveComponentKey = modernRenderer.aX_;
+var resolveComponentKey = modernRenderer.aY_;
 
 module.exports = function defineRenderer(renderingLogic) {
   var renderer = renderingLogic.renderer;
 
-  if (renderer && renderer.aY_) {
+  if (renderer && renderer.aZ_) {
     return renderer;
   }
 
@@ -38,13 +38,13 @@ module.exports = function defineRenderer(renderingLogic) {
     // takes care of re-using existing components.
     renderer = function renderer(input, out) {
       var componentsContext = getComponentsContext(out);
-      var globalComponentsContext = componentsContext.r_;
-      var component = globalComponentsContext.aB_;
-      var isReceivingNewInput = !component || component._k_;
+      var globalComponentsContext = componentsContext.s_;
+      var component = globalComponentsContext.aC_;
+      var isReceivingNewInput = !component || component._l_;
       var parentComponentDef;
 
       if (component) {
-        component._k_ = false;
+        component._l_ = false;
       }
 
       // Render the template associated with the component using the final template
@@ -56,14 +56,14 @@ module.exports = function defineRenderer(renderingLogic) {
       var id;
 
       if (!component && componentLookup) {
-        var key = out.ab_;
+        var key = out.ac_;
 
-        if ((parentComponentDef = componentsContext.q_) && key != null) {
+        if ((parentComponentDef = componentsContext.r_) && key != null) {
           id = resolveComponentKey(key.toString(), parentComponentDef);
         } else if (parentComponentDef) {
-          id = parentComponentDef.aO_();
+          id = parentComponentDef.aP_();
         } else {
-          id = globalComponentsContext.aO_();
+          id = globalComponentsContext.aP_();
         }
 
         component = componentLookup[id];
@@ -96,9 +96,9 @@ module.exports = function defineRenderer(renderingLogic) {
           widgetBody = newProps.renderBody;
         }
       } else if (component) {
-        newProps = newProps || component.Q_;
-        widgetBody = component.___;
-        widgetState = component.aD_;
+        newProps = newProps || component.R_;
+        widgetBody = component._a_;
+        widgetState = component.aE_;
         widgetConfig = component.widgetConfig;
       }
 
@@ -124,7 +124,7 @@ module.exports = function defineRenderer(renderingLogic) {
     };
   }
 
-  renderer.aY_ = true;
+  renderer.aZ_ = true;
   renderer.createOut = template ? template.createOut : renderingLogic.createOut;
   renderer.template = template;
 

package/dist/runtime/components/legacy/dependencies/index.js

@@ -4,14 +4,14 @@ var env = process.env.NODE_ENV;
 var production = !env || env !== "development";
 
 function getRootDeps(template, context) {
-  if (production && template.aZ_) {
-    return template.aZ_;
+  if (production && template.b__) {
+    return template.b__;
   }
 
   attachDepsAndComponentsToTemplate(template, context);
 
-  var deps = template.aZ_ = Object.keys(template.b__).map(key => template.b__[key]);
-  var initModule = getInitModule(template.path, template.t_);
+  var deps = template.b__ = Object.keys(template.ba_).map(key => template.ba_[key]);
+  var initModule = getInitModule(template.path, template.u_);
 
   if (initModule) deps.push(initModule);
 
@@ -42,10 +42,10 @@ function attachDepsAndComponentsToTemplate(target, context) {
   }
 
   if (typeof template.createOut !== "function") return;
-  if (production && target.b__) return;
+  if (production && target.ba_) return;
 
-  var deps = target.b__ = {};
-  var components = target.t_ = {};
+  var deps = target.ba_ = {};
+  var components = target.u_ = {};
 
   if (!template.meta) {
     // eslint-disable-next-line no-console
@@ -88,8 +88,8 @@ function attachDepsAndComponentsToTemplate(target, context) {
 
       attachDepsAndComponentsToTemplate(tag, context);
 
-      if (tag.b__) Object.assign(deps, tag.b__);
-      if (tag.t_) Object.assign(components, tag.t_);
+      if (tag.ba_) Object.assign(deps, tag.ba_);
+      if (tag.u_) Object.assign(components, tag.u_);
     });
   }
 }

package/dist/runtime/components/legacy/helper-getWidgetFromOut.js

@@ -1,8 +1,8 @@
-var getComponentsContext = require("../ComponentsContext").U_;
+var getComponentsContext = require("../ComponentsContext").V_;
 
 module.exports = function (out) {
   var componentsContext = getComponentsContext(out);
-  var componentDef = componentsContext && componentsContext.ba_ || {};
-  componentDef._c = componentDef.v_;
+  var componentDef = componentsContext && componentsContext.bb_ || {};
+  componentDef._c = componentDef.w_;
   return componentDef;
 };