marko 4.24.6 → 4.26.0

package/dist/runtime/components/ComponentDef.js

@@ -2,9 +2,9 @@
 
 var complain;
 var w10Noop = require("warp10/constants").NOOP;
-var componentUtil = require("./util");
-var attachBubblingEvent = componentUtil._H_;
-var addDelegatedEventHandler = require("./event-delegation")._I_;
+var componentUtil = require("@internal/components-util");
+var attachBubblingEvent = componentUtil._U_;
+var addDelegatedEventHandler = require("./event-delegation")._s_;
 var extend = require("raptor-util/extend");
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
@@ -20,24 +20,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._J_ = componentsContext; // The AsyncWriter that this component is associated with
-  this.n_ = component;
+  this.aK_ = componentsContext; // The AsyncWriter that this component is associated with
+  this.v_ = component;
   this.id = componentId;
 
-  this._K_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this._d_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._L_ = false;
+  this._u_ = false;
 
-  this._M_ = false;
-  this._N_ = 0;
+  this.w_ = false;
+  this.x_ = 0;
 
-  this._O_ = 0; // The unique integer to use for the next scoped ID
-  this._P_ = null;
+  this.aL_ = 0; // The unique integer to use for the next scoped ID
+  this.aM_ = null;
 }
 
 ComponentDef.prototype = {
-  _Q_: function (key) {
-    return (this._P_ || (this._P_ = new KeySequence()))._Q_(key);
+  aN_: function (key) {
+    return (this.aM_ || (this.aM_ = new KeySequence())).aN_(key);
   },
 
   /**
@@ -67,8 +67,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  _R_: function () {
-    return this.id + "-c" + this._O_++;
+  aO_: function () {
+    return this.id + "-c" + this.aL_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -77,13 +77,13 @@ ComponentDef.prototype = {
   },
 
   get e_() {
-    return this.n_.e_;
+    return this.v_.e_;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype._Q_;
+ComponentDef.prototype.nk = ComponentDef.prototype.aN_;
 
-ComponentDef._S_ = 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;
@@ -95,15 +95,15 @@ ComponentDef._S_ = 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._T_(typeName, id, isLegacy);
+  var component = typeName /* legacy */ && 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.___ = true;
+  component._c_ = true;
 
   if (isLegacy) {
     component.widgetConfig = componentProps;
-    component._U_ = renderBody;
+    component.___ = renderBody;
   } else if (renderBody) {
     (input || (input = {})).renderBody = renderBody;
   }
@@ -133,25 +133,25 @@ ComponentDef._S_ = function (o, types, global, registry) {
     }
   }
 
-  component.W_ = input;
+  component.R_ = input;
 
   if (extra.b) {
-    component.T_ = extra.b;
+    component.Z_ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component._A_(customEvents, scope);
+    component.aE_(customEvents, scope);
   }
 
-  component.Y_ = global;
+  component.am_ = global;
 
   return {
     id: id,
-    n_: component,
-    _K_: extra.d,
-    _N_: extra.f || 0
+    v_: component,
+    _d_: extra.d,
+    x_: extra.f || 0
   };
 };
 

package/dist/runtime/components/ComponentsContext.js

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

package/dist/runtime/components/GlobalComponentsContext.js

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

package/dist/runtime/components/KeySequence.js

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

package/dist/runtime/components/ServerComponent.js

@@ -5,38 +5,38 @@ var complain;
 class ServerComponent {
   constructor(id, input, out, typeName, customEvents, scope) {
     this.id = id;
-    this.U_ = customEvents;
-    this.M_ = scope;
+    this.X_ = customEvents;
+    this.Y_ = scope;
     this.typeName = typeName;
-    this.T_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
-    this.aa_ = 0;
+    this.Z_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
+    this._a_ = 0;
 
     this.onCreate(input, out);
-    this.ab_ = this.onInput(input, out) || input;
-    if (this.W_ === undefined) {
-      this.W_ = this.ab_;
+    this._b_ = this.onInput(input, out) || input;
+    if (this.R_ === undefined) {
+      this.R_ = this._b_;
     }
     this.onRender(out);
   }
 
   set input(newInput) {
-    this.W_ = newInput;
+    this.R_ = newInput;
   }
 
   get input() {
-    return this.W_;
+    return this.R_;
   }
 
   set state(newState) {
-    this.P_ = newState;
+    this.C_ = newState;
   }
 
   get state() {
-    return this.P_;
+    return this.C_;
   }
 
-  get _y_() {
-    return this.P_;
+  get aD_() {
+    return this.C_;
   }
 
   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._z_[propertyName];
+        return this.D_[propertyName];
       },
       set: function (value) {
-        this._l_(propertyName, value, false /* ensure:false */);
+        this.at_(propertyName, value, false /* ensure:false */);
       }
     });
   }
 }
 
 function State(component) {
-  this.n_ = component;
-  this._z_ = {};
+  this.v_ = component;
+  this.D_ = {};
 
-  this._a_ = false;
-  this._r_ = null;
-  this._q_ = null;
-  this.ac_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
+  this.an_ = false;
+  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
 
   Object.seal(this);
 }
 
 State.prototype = {
-  O_: function () {
+  _t_: function () {
     var self = this;
 
-    self._a_ = false;
-    self._r_ = null;
-    self._q_ = null;
-    self.ac_ = null;
+    self.an_ = false;
+    self.ay_ = null;
+    self.ax_ = null;
+    self.aR_ = null;
   },
 
-  _j_: function (newState) {
+  ar_: function (newState) {
     var state = this;
     var key;
 
-    var rawState = this._z_;
+    var rawState = this.D_;
 
     for (key in rawState) {
       if (!(key in newState)) {
-        state._l_(key, undefined, false /* ensure:false */
+        state.at_(key, undefined, false /* ensure:false */
         , false /* forceDirty:false */
         );
       }
     }
 
     for (key in newState) {
-      state._l_(key, newState[key], true /* ensure:true */
+      state.at_(key, newState[key], true /* ensure:true */
       , false /* forceDirty:false */
       );
     }
   },
-  _l_: function (name, value, shouldEnsure, forceDirty) {
-    var rawState = this._z_;
+  at_: function (name, value, shouldEnsure, forceDirty) {
+    var rawState = this.D_;
 
     if (shouldEnsure) {
       ensure(this, name);
     }
 
     if (forceDirty) {
-      var forcedDirtyState = this.ac_ || (this.ac_ = {});
+      var forcedDirtyState = this.aR_ || (this.aR_ = {});
       forcedDirtyState[name] = true;
     } else if (rawState[name] === value) {
       return;
     }
 
-    if (!this._a_) {
+    if (!this.an_) {
       // 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._a_ = true; // Mark the component state as dirty (i.e. modified)
-      this._r_ = rawState;
-      this._z_ = rawState = extend({}, rawState);
-      this._q_ = {};
-      this.n_._k_();
+      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._q_[name] = value;
+    this.ax_[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._z_;
+    return this.D_;
   }
 };
 

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

@@ -1,8 +1,8 @@
 var eventDelegation = require("./event-delegation");
-var delegateEvent = eventDelegation.ad_;
-var getEventFromEl = eventDelegation.ae_;
+var delegateEvent = eventDelegation.aS_;
+var getEventFromEl = eventDelegation.aT_;
 
-// var componentsUtil = require('./util');
+// var componentsUtil = require('@internal/components-util');
 // var destroyNodeRecursive = componentsUtil.___destroyNodeRecursive;
 // var destroyComponentForNode = componentsUtil.___destroyComponentForNode;
 
@@ -11,13 +11,13 @@ function handleNodeAttach(node, componentsContext) {
     var eventName = "onattach";
     var target = getEventFromEl(node, eventName);
     if (target) {
-      var out = componentsContext.E_;
+      var out = componentsContext.u_;
       var data = out.data;
 
-      var attachTargets = data.af_;
+      var attachTargets = data.aU_;
       if (!attachTargets) {
-        attachTargets = data.af_ = [];
-        out.on("_X_", function () {
+        attachTargets = data.aU_ = [];
+        out.on("aP_", 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.ag_ = handleNodeAttach;
-eventDelegation._f_ = handleNodeDetach;
+eventDelegation.aV_ = handleNodeAttach;
+eventDelegation.ap_ = 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._d_) {
+  if (def.A_) {
     return def;
   }
 
@@ -35,7 +35,7 @@ module.exports = function defineComponent(def, renderer) {
     BaseComponent.call(this, id);
   }
 
-  if (!proto._d_) {
+  if (!proto.A_) {
     // 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._d_ = true;
+  Component.A_ = true;
 
   function State(component) {
     BaseState.call(this, component);
   }
   inherit(State, BaseState);
-  proto._i_ = State;
-  proto._t_ = renderer;
+  proto.S_ = State;
+  proto.T_ = renderer;
 
   return Component;
 };

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

@@ -1,10 +1,10 @@
 var WeakMap = require("../helpers/_weak-map");
 
 module.exports = {
-  ai_: new WeakMap(),
-  aj_: new WeakMap(),
-  K_: new WeakMap(),
-  ak_: new WeakMap(),
-  al_: new WeakMap(),
-  L_: {}
+  _M_: new WeakMap(),
+  _L_: new WeakMap(),
+  _q_: new WeakMap(),
+  aW_: new WeakMap(),
+  _K_: new WeakMap(),
+  _p_: {}
 };

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

@@ -1,7 +1,7 @@
-var componentsUtil = require("./util");
-var runtimeId = componentsUtil.am_;
-var componentLookup = componentsUtil.I_;
-var getMarkoPropsFromEl = componentsUtil.an_;
+var componentsUtil = require("@internal/components-util");
+var runtimeId = componentsUtil._Q_;
+var componentLookup = componentsUtil._n_;
+var getMarkoPropsFromEl = componentsUtil._r_;
 
 var TEXT_NODE = 3;
 
@@ -51,7 +51,7 @@ function delegateEvent(node, eventName, target, event) {
 
   if (extraArgs != null) {
     if (typeof extraArgs === "number") {
-      extraArgs = targetComponent.T_[extraArgs];
+      extraArgs = targetComponent.Z_[extraArgs];
     }
   }
 
@@ -69,11 +69,10 @@ function addDelegatedEventHandler(eventType) {
   }
 }
 
-function addDelegatedEventHandlerToDoc(eventType, doc) {
-  var body = doc.body || doc;
-  var listeners = doc[listenersAttachedKey] = doc[listenersAttachedKey] || {};
+function addDelegatedEventHandlerToHost(eventType, host) {
+  var listeners = host[listenersAttachedKey] = host[listenersAttachedKey] || {};
   if (!listeners[eventType]) {
-    body.addEventListener(eventType, listeners[eventType] = function (event) {
+    (host.body || host).addEventListener(eventType, listeners[eventType] = function (event) {
       var curNode = event.target;
       if (!curNode) {
         return;
@@ -125,13 +124,13 @@ function addDelegatedEventHandlerToDoc(eventType, doc) {
 
 function noop() {}
 
-exports.ag_ = noop;
-exports._f_ = noop;
-exports.ad_ = delegateEvent;
-exports.ae_ = getEventFromEl;
-exports._I_ = addDelegatedEventHandler;
-exports.ao_ = function (doc) {
+exports.aV_ = noop;
+exports.ap_ = noop;
+exports.aS_ = delegateEvent;
+exports.aT_ = getEventFromEl;
+exports._s_ = addDelegatedEventHandler;
+exports._A_ = function (host) {
   Object.keys(delegatedEvents).forEach(function (eventType) {
-    addDelegatedEventHandlerToDoc(eventType, doc);
+    addDelegatedEventHandlerToHost(eventType, host);
   });
 };