marko 5.25.11 → 5.25.12-next.0

package/dist/runtime/components/Component.js

@@ -7,9 +7,9 @@ var domInsert = require("../dom-insert");
 var defaultCreateOut = require("../createOut");
 var getComponentsContext =
 require("./ComponentsContext").e_;
-var componentsUtil = require("./util");
-var componentLookup = componentsUtil.D_;
-var destroyNodeRecursive = componentsUtil.E_;
+var componentsUtil = require("@internal/components-util");
+var componentLookup = componentsUtil.T_;
+var destroyNodeRecursive = componentsUtil._A_;
 var EventEmitter = require("events-light");
 var RenderResult = require("../RenderResult");
 var SubscriptionTracker = require("listener-tracker");
@@ -18,8 +18,8 @@ var updateManager = require("./update-manager");
 var morphdom = require("../vdom/morphdom");
 var eventDelegation = require("./event-delegation");
 var domData = require("./dom-data");
-var componentsByDOMNode = domData.F_;
-var keyedElementsByComponentId = domData.G_;
+var componentsByDOMNode = domData.W_;
+var keyedElementsByComponentId = domData.V_;
 var CONTEXT_KEY = "__subtree_context__";
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -128,8 +128,8 @@ function processUpdateHandlers(component, stateChanges, oldState) {
       handlerMethod.call(component, newValue, oldValue);
     });
 
-    component.I_();
-    component.J_();
+    component._g_();
+    component._a_();
   }
 
   return true;
@@ -169,22 +169,22 @@ var componentProto;
 function Component(id) {
   EventEmitter.call(this);
   this.id = id;
-  this.K_ = null;
-  this.L_ = null;
-  this.M_ = null;
-  this.N_ = null;
-  this.O_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
-  this.P_ = null;
+  this.J_ = null;
+  this._m_ = null;
+  this._N_ = null;
+  this._e_ = null;
+  this.I_ = null; // Used to keep track of bubbling DOM events for components rendered on the server
+  this.G_ = null;
   this.H_ = null;
-  this.Q_ = null;
-  this.R_ = undefined;
-  this.S_ = false;
-  this.T_ = undefined;
-  this.U_ = false;
-  this.V_ = false;
-  this.W_ = false;
-  this.X_ = false;
-  this.Y_ = undefined;
+  this._O_ = null;
+  this.K_ = undefined;
+  this._f_ = false;
+  this._P_ = undefined;
+  this._Q_ = false;
+  this.N_ = false;
+  this._R_ = false;
+  this._S_ = false;
+  this._b_ = undefined;
 
   var ssrKeyedElements = keyedElementsByComponentId[id];
 
@@ -197,7 +197,7 @@ function Component(id) {
 }
 
 Component.prototype = componentProto = {
-  Z_: true,
+  X_: true,
 
   subscribeTo: function (target) {
     if (!target) {
@@ -205,10 +205,10 @@ Component.prototype = componentProto = {
     }
 
     var subscriptions =
-    this.M_ || (
-    this.M_ = new SubscriptionTracker());
+    this._N_ || (
+    this._N_ = new SubscriptionTracker());
 
-    var subscribeToOptions = target.Z_ ?
+    var subscribeToOptions = target.X_ ?
     COMPONENT_SUBSCRIBE_TO_OPTIONS :
     NON_COMPONENT_SUBSCRIBE_TO_OPTIONS;
 
@@ -216,7 +216,7 @@ Component.prototype = componentProto = {
   },
 
   emit: function (eventType) {
-    var customEvents = this.P_;
+    var customEvents = this.G_;
     var target;
 
     if (customEvents && (target = customEvents[eventType])) {
@@ -303,20 +303,20 @@ Component.prototype = componentProto = {
     [];
   },
   destroy: function () {
-    if (this.U_) {
+    if (this._Q_) {
       return;
     }
 
-    var root = this.L_;
+    var root = this._m_;
 
-    this.___();
+    this._w_();
 
     var nodes = root.nodes;
 
     nodes.forEach(function (node) {
       destroyNodeRecursive(node);
 
-      if (eventDelegation._a_(node) !== false) {
+      if (eventDelegation._T_(node) !== false) {
         node.parentNode.removeChild(node);
       }
     });
@@ -327,81 +327,81 @@ Component.prototype = componentProto = {
     this.l_ = {};
   },
 
-  ___: function () {
-    if (this.U_) {
+  _w_: function () {
+    if (this._Q_) {
       return;
     }
 
-    this._b_();
-    this.U_ = true;
+    this._U_();
+    this._Q_ = true;
 
-    componentsByDOMNode.set(this.L_, undefined);
+    componentsByDOMNode.set(this._m_, undefined);
 
-    this.L_ = null;
+    this._m_ = null;
 
     // Unsubscribe from all DOM events
-    this._c_();
+    this._d_();
 
-    var subscriptions = this.M_;
+    var subscriptions = this._N_;
     if (subscriptions) {
       subscriptions.removeAllListeners();
-      this.M_ = null;
+      this._N_ = null;
     }
   },
 
   isDestroyed: function () {
-    return this.U_;
+    return this._Q_;
   },
   get state() {
-    return this.K_;
+    return this.J_;
   },
   set state(newState) {
-    var state = this.K_;
+    var state = this.J_;
     if (!state && !newState) {
       return;
     }
 
     if (!state) {
-      state = this.K_ = new this._d_(this);
+      state = this.J_ = new this._V_(this);
     }
 
-    state._e_(newState || {});
+    state._W_(newState || {});
 
-    if (state.W_) {
-      this._f_();
+    if (state._R_) {
+      this._X_();
     }
 
     if (!newState) {
-      this.K_ = null;
+      this.J_ = null;
     }
   },
   setState: function (name, value) {
-    var state = this.K_;
+    var state = this.J_;
 
     if (!state) {
-      state = this.K_ = new this._d_(this);
+      state = this.J_ = new this._V_(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._g_(k, newState[k], true /* ensure:true */);
+          state._Y_(k, newState[k], true /* ensure:true */);
         }
       }
     } else {
-      state._g_(name, value, true /* ensure:true */);
+      state._Y_(name, value, true /* ensure:true */);
     }
   },
 
   setStateDirty: function (name, value) {
-    var state = this.K_;
+    var state = this.J_;
 
     if (arguments.length == 1) {
       value = state[name];
     }
 
-    state._g_(
+    state._Y_(
     name,
     value,
     true /* ensure:true */,
@@ -410,46 +410,46 @@ Component.prototype = componentProto = {
   },
 
   replaceState: function (newState) {
-    this.K_._e_(newState);
+    this.J_._W_(newState);
   },
 
   get input() {
-    return this.R_;
+    return this.K_;
   },
   set input(newInput) {
-    if (this.X_) {
-      this.R_ = newInput;
+    if (this._S_) {
+      this.K_ = newInput;
     } else {
-      this._h_(newInput);
+      this._Z_(newInput);
     }
   },
 
-  _h_: function (newInput, onInput, out) {
+  _Z_: function (newInput, onInput, out) {
     onInput = onInput || this.onInput;
     var updatedInput;
 
-    var oldInput = this.R_;
-    this.R_ = undefined;
-    this._i_ = out && out[CONTEXT_KEY] || this._i_;
+    var oldInput = this.K_;
+    this.K_ = undefined;
+    this.a__ = out && out[CONTEXT_KEY] || this.a__;
 
     if (onInput) {
       // We need to set a flag to preview `this.input = foo` inside
       // onInput causing infinite recursion
-      this.X_ = true;
+      this._S_ = true;
       updatedInput = onInput.call(this, newInput || {}, out);
-      this.X_ = false;
+      this._S_ = false;
     }
 
-    newInput = this.Q_ = updatedInput || newInput;
+    newInput = this._O_ = updatedInput || newInput;
 
-    if (this.W_ = checkInputChanged(this, oldInput, newInput)) {
-      this._f_();
+    if (this._R_ = checkInputChanged(this, oldInput, newInput)) {
+      this._X_();
     }
 
-    if (this.R_ === undefined) {
-      this.R_ = newInput;
+    if (this.K_ === undefined) {
+      this.K_ = newInput;
       if (newInput && newInput.$global) {
-        this.T_ = newInput.$global;
+        this._P_ = newInput.$global;
       }
     }
 
@@ -457,57 +457,57 @@ Component.prototype = componentProto = {
   },
 
   forceUpdate: function () {
-    this.W_ = true;
-    this._f_();
+    this._R_ = true;
+    this._X_();
   },
 
-  _f_: function () {
-    if (!this.V_) {
-      this.V_ = true;
-      updateManager._j_(this);
+  _X_: function () {
+    if (!this.N_) {
+      this.N_ = true;
+      updateManager.aa_(this);
     }
   },
 
   update: function () {
-    if (this.U_ === true || this._k_ === false) {
+    if (this._Q_ === true || this.ab_ === false) {
       return;
     }
 
-    var input = this.R_;
-    var state = this.K_;
+    var input = this.K_;
+    var state = this.J_;
 
-    if (this.W_ === false && state !== null && state.W_ === true) {
-      if (processUpdateHandlers(this, state._l_, state._m_, state)) {
-        state.W_ = false;
+    if (this._R_ === false && state !== null && state._R_ === true) {
+      if (processUpdateHandlers(this, state.ac_, state.ad_, state)) {
+        state._R_ = false;
       }
     }
 
-    if (this._k_ === true) {
+    if (this.ab_ === true) {
       // The UI component is still dirty after process state handlers
       // then we should rerender
 
       if (this.shouldUpdate(input, state) !== false) {
-        this._n_();
+        this.ae_();
       }
     }
 
-    this.J_();
+    this._a_();
   },
 
-  get _k_() {
+  get ab_() {
     return (
-      this.W_ === true ||
-      this.K_ !== null && this.K_.W_ === true);
+      this._R_ === true ||
+      this.J_ !== null && this.J_._R_ === true);
 
   },
 
-  J_: function () {
-    this.W_ = false;
-    this.V_ = false;
-    this.Q_ = null;
-    var state = this.K_;
+  _a_: function () {
+    this._R_ = false;
+    this.N_ = false;
+    this._O_ = null;
+    var state = this.J_;
     if (state) {
-      state.J_();
+      state._a_();
     }
   },
 
@@ -515,71 +515,71 @@ Component.prototype = componentProto = {
     return true;
   },
 
-  _n_: function () {
+  ae_: function () {
     var self = this;
-    var renderer = self._o_;
+    var renderer = self.af_;
 
     if (!renderer) {
       throw TypeError();
     }
 
-    var input = this.Q_ || this.R_;
+    var input = this._O_ || this.K_;
 
-    updateManager._p_(function () {
-      self._q_(input, false).afterInsert(self.Y_);
+    updateManager.ag_(function () {
+      self._n_(input, false).afterInsert(self._b_);
     });
 
-    this.J_();
+    this._a_();
   },
 
-  _q_: function (input, isHydrate) {
-    var host = this.Y_;
-    var globalData = this.T_;
-    var rootNode = this.L_;
-    var renderer = this._o_;
+  _n_: function (input, isHydrate) {
+    var host = this._b_;
+    var globalData = this._P_;
+    var rootNode = this._m_;
+    var renderer = this.af_;
     var createOut = renderer.createOut || defaultCreateOut;
     var out = createOut(globalData);
     out.sync();
-    out.Y_ = this.Y_;
-    out[CONTEXT_KEY] = this._i_;
+    out._b_ = this._b_;
+    out[CONTEXT_KEY] = this.a__;
 
     var componentsContext = getComponentsContext(out);
     var globalComponentsContext = componentsContext.f_;
-    globalComponentsContext._r_ = this;
+    globalComponentsContext.ah_ = this;
     globalComponentsContext.g_ = isHydrate;
 
     renderer(input, out);
 
     var result = new RenderResult(out);
 
-    var targetNode = out.C_()._s_;
+    var targetNode = out._M_().ai_;
 
     morphdom(rootNode, targetNode, host, componentsContext);
 
     return result;
   },
 
-  _t_: function () {
-    var root = this.L_;
+  aj_: function () {
+    var root = this._m_;
     root.remove();
     return root;
   },
 
-  _c_: function () {
-    var eventListenerHandles = this.N_;
+  _d_: function () {
+    var eventListenerHandles = this._e_;
     if (eventListenerHandles) {
       eventListenerHandles.forEach(removeListener);
-      this.N_ = null;
+      this._e_ = null;
     }
   },
 
-  get _u_() {
-    var state = this.K_;
-    return state && state._v_;
+  get ak_() {
+    var state = this.J_;
+    return state && state.al_;
   },
 
-  _w_: function (customEvents, scope) {
-    var finalCustomEvents = this.P_ = {};
+  am_: function (customEvents, scope) {
+    var finalCustomEvents = this.G_ = {};
     this.H_ = scope;
 
     customEvents.forEach(function (customEvent) {
@@ -595,7 +595,7 @@ Component.prototype = componentProto = {
   },
 
   get el() {
-    return walkFragments(this.L_);
+    return walkFragments(this._m_);
   },
 
   get els() {
@@ -605,43 +605,43 @@ Component.prototype = componentProto = {
 
 
 
-    return (this.L_ ? this.L_.nodes : []).filter(function (
+    return (this._m_ ? this._m_.nodes : []).filter(function (
     el)
     {
       return el.nodeType === ELEMENT_NODE;
     });
   },
 
-  _x_: emit,
-  _y_(input, out) {
+  an_: emit,
+  ao_(input, out) {
     this.onCreate && this.onCreate(input, out);
-    this._x_("create", input, out);
+    this.an_("create", input, out);
   },
 
-  _z_(out) {
+  ap_(out) {
     this.onRender && this.onRender(out);
-    this._x_("render", out);
+    this.an_("render", out);
   },
 
-  I_() {
+  _g_() {
     this.onUpdate && this.onUpdate();
-    this._x_("update");
+    this.an_("update");
   },
 
-  _A_() {
+  _h_() {
     this.onMount && this.onMount();
-    this._x_("mount");
+    this.an_("mount");
   },
 
-  _b_() {
+  _U_() {
     this.onDestroy && this.onDestroy();
-    this._x_("destroy");
+    this.an_("destroy");
   }
 };
 
 componentProto.elId = componentProto.getElId;
-componentProto._B_ = componentProto.update;
-componentProto._C_ = componentProto.destroy;
+componentProto.aq_ = componentProto.update;
+componentProto.ar_ = componentProto.destroy;
 
 // Add all of the following DOM methods to Component.prototype:
 // - appendTo(referenceEl)
@@ -653,7 +653,7 @@ componentProto._C_ = componentProto.destroy;
 domInsert(
 componentProto,
 function getEl(component) {
-  return component._t_();
+  return component.aj_();
 },
 function afterInsert(component) {
   return component;

package/dist/runtime/components/ComponentDef.js

@@ -1,10 +1,10 @@
 "use strict";
 
 var w10Noop = require("warp10/constants").NOOP;
-var componentUtil = require("./util");
-var attachBubblingEvent = componentUtil._D_;
+var componentUtil = require("@internal/components-util");
+var attachBubblingEvent = componentUtil._C_;
 var addDelegatedEventHandler =
-require("./event-delegation")._E_;
+require("./event-delegation").___;
 var extend = require("raptor-util/extend");
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
@@ -18,25 +18,25 @@ var FLAG_HAS_RENDER_BODY = 2;
  * later (after the rendered HTML has been added to the DOM)
  */
 function ComponentDef(component, componentId, componentsContext) {
-  this._F_ = componentsContext; // The AsyncWriter that this component is associated with
+  this.as_ = componentsContext; // The AsyncWriter that this component is associated with
   this.i_ = component;
   this.id = componentId;
 
-  this._G_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this.O_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._H_ = false;
+  this._c_ = false;
 
-  this._I_ = false;
-  this._J_ = 0;
+  this.B_ = false;
+  this.C_ = 0;
 
-  this._K_ = 0; // The unique integer to use for the next scoped ID
-  this._L_ = null;
+  this.at_ = 0; // The unique integer to use for the next scoped ID
+  this.au_ = null;
 }
 
 ComponentDef.prototype = {
-  _M_: function (key) {
+  av_: function (key) {
     return (
-    this._L_ || (this._L_ = new KeySequence()))._M_(
+    this.au_ || (this.au_ = new KeySequence())).av_(
     key);
   },
 
@@ -70,8 +70,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  _N_: function () {
-    return this.id + "-c" + this._K_++;
+  aw_: function () {
+    return this.id + "-c" + this.at_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -79,14 +79,14 @@ ComponentDef.prototype = {
     return attachBubblingEvent(this, handlerMethodName, isOnce, extraArgs);
   },
 
-  get _O_() {
-    return this.i_._O_;
+  get Y_() {
+    return this.i_.Y_;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype._M_;
+ComponentDef.prototype.nk = ComponentDef.prototype.av_;
 
-ComponentDef._P_ = function (o, types, global, registry) {
+ComponentDef._l_ = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
@@ -95,11 +95,11 @@ ComponentDef._P_ = function (o, types, global, registry) {
   var state = extra.s;
   var componentProps = extra.w;
   var flags = extra.f;
-  var component = registry._Q_(typeName, id);
+  var component = registry._o_(typeName, id);
 
   // Prevent newly created component from being queued for update since we area
   // just building it from the server info
-  component.V_ = true;
+  component.N_ = true;
 
   if (flags & FLAG_HAS_RENDER_BODY) {
     (input || (input = {})).renderBody = w10Noop;
@@ -130,25 +130,25 @@ ComponentDef._P_ = function (o, types, global, registry) {
     }
   }
 
-  component.R_ = input;
+  component.K_ = input;
 
   if (extra.b) {
-    component.O_ = extra.b;
+    component.I_ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component._w_(customEvents, scope);
+    component.am_(customEvents, scope);
   }
 
-  component.T_ = global;
+  component._P_ = global;
 
   return {
     id: id,
     i_: component,
-    _G_: extra.d,
-    _J_: extra.f || 0
+    O_: extra.d,
+    C_: extra.f || 0
   };
 };