marko 5.29.2 → 5.30.1

package/dist/runtime/components/ComponentDef.js

@@ -2,15 +2,17 @@
 
 var w10Noop = require("warp10/constants").NOOP;
 var componentUtil = require("@internal/components-util");
-var attachBubblingEvent = componentUtil._C_;
+var attachBubblingEvent = componentUtil._W_;
 var addDelegatedEventHandler =
-require("./event-delegation").___;
+require("./event-delegation")._u_;
 var extend = require("raptor-util/extend");
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
 
 var FLAG_WILL_RERENDER_IN_BROWSER = 1;
 var FLAG_HAS_RENDER_BODY = 2;
+var FLAG_IS_LEGACY = 4;
+var FLAG_OLD_HYDRATE_NO_CREATE = 8;
 
 /**
  * A ComponentDef is used to hold the metadata collected at runtime for
@@ -18,25 +20,25 @@ var FLAG_HAS_RENDER_BODY = 2;
  * later (after the rendered HTML has been added to the DOM)
  */
 function ComponentDef(component, componentId, componentsContext) {
-  this.as_ = componentsContext; // The AsyncWriter that this component is associated with
+  this.aH_ = componentsContext; // The AsyncWriter that this component is associated with
   this.i_ = component;
   this.id = componentId;
 
-  this.O_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this._g_ = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._c_ = false;
+  this._w_ = false;
 
   this.B_ = false;
   this.C_ = 0;
 
-  this.at_ = 0; // The unique integer to use for the next scoped ID
-  this.au_ = null;
+  this.aI_ = 0; // The unique integer to use for the next scoped ID
+  this.aJ_ = null;
 }
 
 ComponentDef.prototype = {
-  av_: function (key) {
+  aK_: function (key) {
     return (
-    this.au_ || (this.au_ = new KeySequence())).av_(
+    this.aJ_ || (this.aJ_ = new KeySequence())).aK_(
     key);
   },
 
@@ -70,8 +72,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  aw_: function () {
-    return this.id + "-c" + this.at_++;
+  aL_: function () {
+    return this.id + "-c" + this.aI_++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -79,33 +81,45 @@ ComponentDef.prototype = {
     return attachBubblingEvent(this, handlerMethodName, isOnce, extraArgs);
   },
 
-  get Y_() {
-    return this.i_.Y_;
+  get _s_() {
+    return this.i_._s_;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype.av_;
+ComponentDef.prototype.nk = ComponentDef.prototype.aK_;
 
-ComponentDef._l_ = function (o, types, global, registry) {
+ComponentDef._F_ = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
   var extra = o[3] || EMPTY_OBJECT;
 
   var state = extra.s;
-  var componentProps = extra.w;
+  var componentProps = extra.w || EMPTY_OBJECT;
   var flags = extra.f;
-  var component = registry._o_(typeName, id);
+  var isLegacy = flags & FLAG_IS_LEGACY;
+  var renderBody = flags & FLAG_HAS_RENDER_BODY ? w10Noop : extra.r;
+
+  var component =
+  typeName /* legacy */ &&
+  registry._I_(typeName, id, isLegacy);
 
   // Prevent newly created component from being queued for update since we area
   // just building it from the server info
-  component.N_ = true;
+  component._f_ = true;
 
-  if (flags & FLAG_HAS_RENDER_BODY) {
-    (input || (input = {})).renderBody = w10Noop;
+  if (isLegacy) {
+    component.widgetConfig = componentProps;
+    component._c_ = renderBody;
+  } else if (renderBody) {
+    (input || (input = {})).renderBody = renderBody;
   }
 
-  if (flags & FLAG_WILL_RERENDER_IN_BROWSER) {
+  if (
+  !isLegacy &&
+  flags & FLAG_WILL_RERENDER_IN_BROWSER &&
+  !(flags & FLAG_OLD_HYDRATE_NO_CREATE))
+  {
     if (component.onCreate) {
       component.onCreate(input, { global: global });
     }
@@ -125,29 +139,29 @@ ComponentDef._l_ = function (o, types, global, registry) {
       component.state = state;
     }
 
-    if (componentProps) {
+    if (!isLegacy && componentProps) {
       extend(component, componentProps);
     }
   }
 
-  component.K_ = input;
+  component.U_ = input;
 
   if (extra.b) {
-    component.I_ = extra.b;
+    component._b_ = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component.am_(customEvents, scope);
+    component.aB_(customEvents, scope);
   }
 
-  component._P_ = global;
+  component.ai_ = global;
 
   return {
     id: id,
     i_: component,
-    O_: extra.d,
+    _g_: extra.d,
     C_: extra.f || 0
   };
 };

package/dist/runtime/components/ComponentsContext.js

@@ -11,9 +11,9 @@ function ComponentsContext(out, parentComponentsContext) {
 
     var nestedContextsForParent;
     if (
-    !(nestedContextsForParent = parentComponentsContext.P_))
+    !(nestedContextsForParent = parentComponentsContext._h_))
     {
-      nestedContextsForParent = parentComponentsContext.P_ = [];
+      nestedContextsForParent = parentComponentsContext._h_ = [];
     }
 
     nestedContextsForParent.push(this);
@@ -29,18 +29,18 @@ function ComponentsContext(out, parentComponentsContext) {
   this.b_ = [];
   this.A_ = out;
   this.k_ = componentDef;
-  this.P_ = undefined;
+  this._h_ = undefined;
   this.p_ =
   parentComponentsContext && parentComponentsContext.p_;
 }
 
 ComponentsContext.prototype = {
-  _K_: function (host) {
+  ad_: function (host) {
     var componentDefs = this.b_;
 
-    ComponentsContext._q_(componentDefs, host);
+    ComponentsContext._K_(componentDefs, host);
 
-    this.A_.emit("ax_");
+    this.A_.emit("aM_");
 
     // 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")._B_;
+require("@internal/components-util")._V_;
 
 function GlobalComponentsContext(out) {
   this.z_ = {};
-  this.ah_ = undefined;
-  this.aw_ = nextComponentIdProvider(out);
+  this.ax_ = undefined;
+  this.aL_ = nextComponentIdProvider(out);
 }
 
 module.exports = GlobalComponentsContext;

package/dist/runtime/components/KeySequence.js

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

package/dist/runtime/components/ServerComponent.js

@@ -4,38 +4,38 @@
 class ServerComponent {
   constructor(id, input, out, typeName, customEvents, scope) {
     this.id = id;
-    this.G_ = customEvents;
-    this.H_ = scope;
+    this.___ = customEvents;
+    this._a_ = scope;
     this.typeName = typeName;
-    this.I_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
-    this.L_ = 0;
+    this._b_ = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
+    this._d_ = 0;
 
     this.onCreate(input, out);
-    this.M_ = this.onInput(input, out) || input;
-    if (this.K_ === undefined) {
-      this.K_ = this.M_;
+    this._e_ = this.onInput(input, out) || input;
+    if (this.U_ === undefined) {
+      this.U_ = this._e_;
     }
     this.onRender(out);
   }
 
   set input(newInput) {
-    this.K_ = newInput;
+    this.U_ = newInput;
   }
 
   get input() {
-    return this.K_;
+    return this.U_;
   }
 
   set state(newState) {
-    this.J_ = newState;
+    this.G_ = newState;
   }
 
   get state() {
-    return this.J_;
+    return this.G_;
   }
 
-  get ak_() {
-    return this.J_;
+  get aA_() {
+    return this.G_;
   }
 
   elId(nestedId) {

package/dist/runtime/components/State.js

@@ -5,10 +5,10 @@ function ensure(state, propertyName) {
   if (!(propertyName in proto)) {
     Object.defineProperty(proto, propertyName, {
       get: function () {
-        return this.al_[propertyName];
+        return this.H_[propertyName];
       },
       set: function (value) {
-        this._Y_(propertyName, value, false /* ensure:false */);
+        this.ap_(propertyName, value, false /* ensure:false */);
       }
     });
   }
@@ -16,35 +16,35 @@ function ensure(state, propertyName) {
 
 function State(component) {
   this.i_ = component;
-  this.al_ = {};
+  this.H_ = {};
 
-  this._R_ = false;
-  this.ad_ = null;
-  this.ac_ = null;
-  this.az_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
+  this.aj_ = false;
+  this.au_ = null;
+  this.at_ = null;
+  this.aO_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
 
   Object.seal(this);
 }
 
 State.prototype = {
-  _a_: function () {
+  _v_: function () {
     var self = this;
 
-    self._R_ = false;
-    self.ad_ = null;
-    self.ac_ = null;
-    self.az_ = null;
+    self.aj_ = false;
+    self.au_ = null;
+    self.at_ = null;
+    self.aO_ = null;
   },
 
-  _W_: function (newState) {
+  an_: function (newState) {
     var state = this;
     var key;
 
-    var rawState = this.al_;
+    var rawState = this.H_;
 
     for (key in rawState) {
       if (!(key in newState)) {
-        state._Y_(
+        state.ap_(
         key,
         undefined,
         false /* ensure:false */,
@@ -54,7 +54,7 @@ State.prototype = {
     }
 
     for (key in newState) {
-      state._Y_(
+      state.ap_(
       key,
       newState[key],
       true /* ensure:true */,
@@ -62,32 +62,32 @@ State.prototype = {
 
     }
   },
-  _Y_: function (name, value, shouldEnsure, forceDirty) {
-    var rawState = this.al_;
+  ap_: function (name, value, shouldEnsure, forceDirty) {
+    var rawState = this.H_;
 
     if (shouldEnsure) {
       ensure(this, name);
     }
 
     if (forceDirty) {
-      var forcedDirtyState = this.az_ || (this.az_ = {});
+      var forcedDirtyState = this.aO_ || (this.aO_ = {});
       forcedDirtyState[name] = true;
     } else if (rawState[name] === value) {
       return;
     }
 
-    if (!this._R_) {
+    if (!this.aj_) {
       // 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._R_ = true; // Mark the component state as dirty (i.e. modified)
-      this.ad_ = rawState;
-      this.al_ = rawState = extend({}, rawState);
-      this.ac_ = {};
-      this.i_._X_();
+      this.aj_ = true; // Mark the component state as dirty (i.e. modified)
+      this.au_ = rawState;
+      this.H_ = rawState = extend({}, rawState);
+      this.at_ = {};
+      this.i_.ao_();
     }
 
-    this.ac_[name] = value;
+    this.at_[name] = value;
 
     if (value === undefined) {
       // Don't store state properties with an undefined or null value
@@ -98,7 +98,7 @@ State.prototype = {
     }
   },
   toJSON: function () {
-    return this.al_;
+    return this.H_;
   }
 };
 

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

@@ -1,6 +1,6 @@
 "use strict";var eventDelegation = require("./event-delegation");
-var delegateEvent = eventDelegation.aA_;
-var getEventFromEl = eventDelegation.aB_;
+var delegateEvent = eventDelegation.aP_;
+var getEventFromEl = eventDelegation.aQ_;
 
 // var componentsUtil = require('@internal/components-util');
 // var destroyNodeRecursive = componentsUtil.___destroyNodeRecursive;
@@ -14,10 +14,10 @@ function handleNodeAttach(node, componentsContext) {
       var out = componentsContext.A_;
       var data = out.data;
 
-      var attachTargets = data.aC_;
+      var attachTargets = data.aR_;
       if (!attachTargets) {
-        attachTargets = data.aC_ = [];
-        out.on("ax_", function () {
+        attachTargets = data.aR_ = [];
+        out.on("aM_", 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.aD_ = handleNodeAttach;
-eventDelegation._T_ = handleNodeDetach;
+eventDelegation.aS_ = handleNodeAttach;
+eventDelegation.al_ = 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.X_) {
+  if (def.E_) {
     return def;
   }
 
@@ -35,7 +35,7 @@ module.exports = function defineComponent(def, renderer) {
     BaseComponent.call(this, id);
   }
 
-  if (!proto.X_) {
+  if (!proto.E_) {
     // 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.X_ = true;
+  Component.E_ = true;
 
   function State(component) {
     BaseState.call(this, component);
   }
   inherit(State, BaseState);
-  proto._V_ = State;
-  proto.af_ = renderer;
+  proto.V_ = State;
+  proto.W_ = renderer;
 
   return Component;
 };

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

@@ -1,8 +1,8 @@
 "use strict";module.exports = {
-  _u_: new WeakMap(),
-  _t_: new WeakMap(),
-  W_: new WeakMap(),
-  aE_: new WeakMap(),
-  _s_: new WeakMap(),
-  V_: {}
+  _O_: new WeakMap(),
+  _N_: new WeakMap(),
+  _r_: new WeakMap(),
+  aT_: new WeakMap(),
+  _M_: new WeakMap(),
+  _q_: {}
 };

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

@@ -1,7 +1,7 @@
 "use strict";var componentsUtil = require("@internal/components-util");
-var runtimeId = componentsUtil._y_;
-var componentLookup = componentsUtil.T_;
-var getMarkoPropsFromEl = componentsUtil.Z_;
+var runtimeId = componentsUtil._S_;
+var componentLookup = componentsUtil._o_;
+var getMarkoPropsFromEl = componentsUtil._t_;
 
 var TEXT_NODE = 3;
 
@@ -54,7 +54,7 @@ function delegateEvent(node, eventName, target, event) {
 
   if (extraArgs != null) {
     if (typeof extraArgs === "number") {
-      extraArgs = targetComponent.I_[extraArgs];
+      extraArgs = targetComponent._b_[extraArgs];
     }
   }
 
@@ -132,12 +132,12 @@ function addDelegatedEventHandlerToHost(eventType, host) {
 
 function noop() {}
 
-exports.aD_ = noop;
-exports._T_ = noop;
-exports.aA_ = delegateEvent;
-exports.aB_ = getEventFromEl;
-exports.___ = addDelegatedEventHandler;
-exports._i_ = function (host) {
+exports.aS_ = noop;
+exports.al_ = noop;
+exports.aP_ = delegateEvent;
+exports.aQ_ = getEventFromEl;
+exports._u_ = addDelegatedEventHandler;
+exports._C_ = function (host) {
   Object.keys(delegatedEvents).forEach(function (eventType) {
     addDelegatedEventHandlerToHost(eventType, host);
   });

package/dist/runtime/components/legacy/browser.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": [
+    {
+      "type": "require",
+      "path": "./index",
+      "run": true
+    }
+  ]
+}

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

@@ -0,0 +1,32 @@
+"use strict"; /**
+ * Define a new UI component that includes component and renderer.
+ *
+ * @param  {Object} def The definition of the UI component (component methods, component constructor, rendering methods, etc.)
+ * @return {Component} The resulting Component with renderer
+ */
+var defineRenderer;
+var defineWidget;
+
+module.exports = function defineComponent(def) {
+  // eslint-disable-next-line no-constant-condition
+
+
+
+
+  if (def.E_) {
+    return def;
+  }
+
+  var renderer;
+
+  if (def.template || def.renderer) {
+    renderer = defineRenderer(def);
+  } else {
+    throw new Error('Expected "template" or "renderer"');
+  }
+
+  return defineWidget(def, renderer);
+};
+
+defineRenderer = require("./defineRenderer-legacy");
+defineWidget = require("./defineWidget-legacy");