marko 5.36.5 → 5.37.0

package/dist/runtime/components/ComponentDef.js

@@ -1,12 +1,12 @@
 "use strict";
 // eslint-disable-next-line no-constant-binary-expression
-
+var complain = "MARKO_DEBUG" && require("complain");
 var extend = require("raptor-util/extend");
 var componentUtil = require("@internal/components-util");
-var w10NOOP = require("../helpers/serialize-noop").aK_;
-var attachBubblingEvent = componentUtil._U_;
+var w10NOOP = require("../helpers/serialize-noop").___noop;
+var attachBubblingEvent = componentUtil.___attachBubblingEvent;
 var addDelegatedEventHandler =
-require("./event-delegation")._t_;
+require("./event-delegation").___addDelegatedEventHandler;
 var KeySequence = require("./KeySequence");
 var EMPTY_OBJECT = {};
 
@@ -21,26 +21,26 @@ var FLAG_OLD_HYDRATE_NO_CREATE = 8;
  * later (after the rendered HTML has been added to the DOM)
  */
 function ComponentDef(component, componentId, componentsContext) {
-  this.aL_ = componentsContext; // The AsyncWriter that this component is associated with
-  this.t_ = component;
+  this.___componentsContext = componentsContext; // The AsyncWriter that this component is associated with
+  this.___component = component;
   this.id = componentId;
 
-  this._d_ = undefined; // An array of DOM events that need to be added (in sets of three)
+  this.___domEvents = undefined; // An array of DOM events that need to be added (in sets of three)
 
-  this._v_ = false;
+  this.___isExisting = false;
 
-  this.u_ = false;
-  this.v_ = 0;
+  this.___renderBoundary = false;
+  this.___flags = 0;
 
-  this.aM_ = 0; // The unique integer to use for the next scoped ID
-  this.aN_ = null;
+  this.___nextIdIndex = 0; // The unique integer to use for the next scoped ID
+  this.___keySequence = null;
 }
 
 ComponentDef.prototype = {
-  aO_: function (key) {
+  ___nextKey: function (key) {
     return (
-    this.aN_ || (this.aN_ = new KeySequence())).aO_(
-      key);
+    this.___keySequence || (this.___keySequence = new KeySequence())).
+    ___nextKey(key);
   },
 
   /**
@@ -55,9 +55,9 @@ ComponentDef.prototype = {
     } else {
       if (typeof nestedId !== "string") {
         // eslint-disable-next-line no-constant-condition
-
-
-
+        if ("MARKO_DEBUG") {
+          complain("Using non strings as keys is deprecated.");
+        }
 
         nestedId = String(nestedId);
       }
@@ -73,8 +73,8 @@ ComponentDef.prototype = {
   /**
    * Returns the next auto generated unique ID for a nested DOM element or nested DOM component
    */
-  aP_: function () {
-    return this.id + "-c" + this.aM_++;
+  ___nextComponentId: function () {
+    return this.id + "-c" + this.___nextIdIndex++;
   },
 
   d: function (eventName, handlerMethodName, isOnce, extraArgs) {
@@ -82,14 +82,14 @@ ComponentDef.prototype = {
     return attachBubblingEvent(this, handlerMethodName, isOnce, extraArgs);
   },
 
-  get _r_() {
-    return this.t_._r_;
+  get ___type() {
+    return this.___component.___type;
   }
 };
 
-ComponentDef.prototype.nk = ComponentDef.prototype.aO_;
+ComponentDef.prototype.nk = ComponentDef.prototype.___nextKey;
 
-ComponentDef._E_ = function (o, types, global, registry) {
+ComponentDef.___deserialize = function (o, types, global, registry) {
   var id = o[0];
   var typeName = types[o[1]];
   var input = o[2] || null;
@@ -103,16 +103,16 @@ ComponentDef._E_ = function (o, types, global, registry) {
 
   var component =
   typeName /* legacy */ &&
-  registry._H_(typeName, id, isLegacy);
+  registry.___createComponent(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.al_ = global;
+  component.___updateQueued = true;
+  component.___global = global;
 
   if (isLegacy) {
     component.widgetConfig = componentProps;
-    component.___ = renderBody;
+    component.___widgetBody = renderBody;
   } else if (renderBody) {
     (input || (input = {})).renderBody = renderBody;
   }
@@ -146,23 +146,23 @@ ComponentDef._E_ = function (o, types, global, registry) {
     }
   }
 
-  component.P_ = input;
+  component.___input = input;
 
   if (extra.b) {
-    component.Z_ = extra.b;
+    component.___bubblingDomEvents = extra.b;
   }
 
   var scope = extra.p;
   var customEvents = extra.e;
   if (customEvents) {
-    component.aE_(customEvents, scope);
+    component.___setCustomEvents(customEvents, scope);
   }
 
   return {
     id: id,
-    t_: component,
-    _d_: extra.d,
-    v_: extra.f || 0
+    ___component: component,
+    ___domEvents: extra.d,
+    ___flags: extra.f || 0
   };
 };
 

package/dist/runtime/components/ComponentsContext.js

@@ -6,54 +6,54 @@ function ComponentsContext(out, parentComponentsContext) {
   var componentDef;
 
   if (parentComponentsContext) {
-    globalComponentsContext = parentComponentsContext.q_;
-    componentDef = parentComponentsContext.p_;
+    globalComponentsContext = parentComponentsContext.___globalContext;
+    componentDef = parentComponentsContext.___componentDef;
 
     var nestedContextsForParent;
     if (
-    !(nestedContextsForParent = parentComponentsContext._e_))
+    !(nestedContextsForParent = parentComponentsContext.___nestedContexts))
     {
-      nestedContextsForParent = parentComponentsContext._e_ = [];
+      nestedContextsForParent = parentComponentsContext.___nestedContexts = [];
     }
 
     nestedContextsForParent.push(this);
   } else {
-    globalComponentsContext = out.global.b_;
+    globalComponentsContext = out.global.___components;
     if (globalComponentsContext === undefined) {
-      out.global.b_ = globalComponentsContext =
+      out.global.___components = globalComponentsContext =
       new GlobalComponentsContext(out);
     }
   }
 
-  this.q_ = globalComponentsContext;
-  this.b_ = [];
-  this.s_ = out;
-  this.p_ = componentDef;
-  this._e_ = undefined;
-  this.w_ =
-  parentComponentsContext && parentComponentsContext.w_;
+  this.___globalContext = globalComponentsContext;
+  this.___components = [];
+  this.___out = out;
+  this.___componentDef = componentDef;
+  this.___nestedContexts = undefined;
+  this.___isPreserved =
+  parentComponentsContext && parentComponentsContext.___isPreserved;
 }
 
 ComponentsContext.prototype = {
-  ag_: function (host) {
-    var componentDefs = this.b_;
+  ___initComponents: function (host) {
+    var componentDefs = this.___components;
 
-    ComponentsContext._J_(componentDefs, host);
+    ComponentsContext.___initClientRendered(componentDefs, host);
 
-    this.s_.emit("aQ_");
+    this.___out.emit("___componentsInitialized");
 
     // Reset things stored in global since global is retained for
     // future renders
-    this.s_.global.b_ = undefined;
+    this.___out.global.___components = undefined;
 
     return componentDefs;
   }
 };
 
 function getComponentsContext(out) {
-  return out.b_ || (out.b_ = new ComponentsContext(out));
+  return out.___components || (out.___components = new ComponentsContext(out));
 }
 
 module.exports = exports = ComponentsContext;
 
-exports.T_ = getComponentsContext;
+exports.___getComponentsContext = getComponentsContext;

package/dist/runtime/components/GlobalComponentsContext.js

@@ -1,10 +1,10 @@
 "use strict";var nextComponentIdProvider =
-require("@internal/components-util")._T_;
+require("@internal/components-util").___nextComponentIdProvider;
 
 function GlobalComponentsContext(out) {
-  this.r_ = {};
-  this.aA_ = undefined;
-  this.aP_ = nextComponentIdProvider(out);
+  this.___renderedComponentsById = {};
+  this.___rerenderComponent = undefined;
+  this.___nextComponentId = nextComponentIdProvider(out);
 }
 
 module.exports = GlobalComponentsContext;

package/dist/runtime/components/KeySequence.js

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

package/dist/runtime/components/ServerComponent.js

@@ -1,42 +1,42 @@
 "use strict";
 // eslint-disable-next-line no-constant-binary-expression
-
+var complain = "MARKO_DEBUG" && require("complain");
 
 class ServerComponent {
   constructor(id, input, out, typeName, customEvents, scope) {
     this.id = id;
-    this.X_ = customEvents;
-    this.Y_ = scope;
+    this.___customEvents = customEvents;
+    this.___scope = 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.___bubblingDomEvents = undefined; // Used to keep track of bubbling DOM events for components rendered on the server
+    this.___bubblingDomEventsExtraArgsCount = 0;
 
     this.onCreate(input, out);
-    this._b_ = this.onInput(input, out) || input;
-    if (this.P_ === undefined) {
-      this.P_ = this._b_;
+    this.___updatedInput = this.onInput(input, out) || input;
+    if (this.___input === undefined) {
+      this.___input = this.___updatedInput;
     }
     this.onRender(out);
   }
 
   set input(newInput) {
-    this.P_ = newInput;
+    this.___input = newInput;
   }
 
   get input() {
-    return this.P_;
+    return this.___input;
   }
 
   set state(newState) {
-    this.A_ = newState;
+    this.___state = newState;
   }
 
   get state() {
-    return this.A_;
+    return this.___state;
   }
 
-  get aD_() {
-    return this.A_;
+  get ___rawState() {
+    return this.___state;
   }
 
   elId(nestedId) {
@@ -47,9 +47,9 @@ class ServerComponent {
     } else {
       if (typeof nestedId !== "string") {
         // eslint-disable-next-line no-constant-condition
-
-
-
+        if ("MARKO_DEBUG") {
+          complain("Using non strings as keys is deprecated.");
+        }
 
         nestedId = String(nestedId);
       }

package/dist/runtime/components/State.js

@@ -5,42 +5,42 @@ function ensure(state, propertyName) {
   if (!(propertyName in proto)) {
     Object.defineProperty(proto, propertyName, {
       get: function () {
-        return this.B_[propertyName];
+        return this.___raw[propertyName];
       },
       set: function (value) {
-        this.as_(propertyName, value, false /* ensure:false */);
+        this.___set(propertyName, value, false /* ensure:false */);
       }
     });
   }
 }
 
 function State(component) {
-  this.t_ = component;
-  this.B_ = {};
+  this.___component = component;
+  this.___raw = {};
 
-  this.am_ = false;
-  this.ax_ = null;
-  this.aw_ = null;
-  this.aS_ = null; // An object that we use to keep tracking of state properties that were forced to be dirty
+  this.___dirty = false;
+  this.___old = null;
+  this.___changes = null;
+  this.___forced = null; // An object that we use to keep tracking of state properties that were forced to be dirty
 
   Object.seal(this);
 }
 
 State.prototype = {
-  _u_: function () {
-    this.am_ = false;
-    this.ax_ = null;
-    this.aw_ = null;
-    this.aS_ = null;
+  ___reset: function () {
+    this.___dirty = false;
+    this.___old = null;
+    this.___changes = null;
+    this.___forced = null;
   },
 
-  aq_: function (newState) {
+  ___replace: function (newState) {
     var key;
-    var rawState = this.B_;
+    var rawState = this.___raw;
 
     for (key in rawState) {
       if (!(key in newState)) {
-        this.as_(
+        this.___set(
           key,
           undefined,
           false /* ensure:false */,
@@ -50,7 +50,7 @@ State.prototype = {
     }
 
     for (key in newState) {
-      this.as_(
+      this.___set(
         key,
         newState[key],
         true /* ensure:true */,
@@ -58,32 +58,32 @@ State.prototype = {
       );
     }
   },
-  as_: function (name, value, shouldEnsure, forceDirty) {
-    var rawState = this.B_;
+  ___set: function (name, value, shouldEnsure, forceDirty) {
+    var rawState = this.___raw;
 
     if (shouldEnsure) {
       ensure(this, name);
     }
 
     if (forceDirty) {
-      var forcedDirtyState = this.aS_ || (this.aS_ = {});
+      var forcedDirtyState = this.___forced || (this.___forced = {});
       forcedDirtyState[name] = true;
     } else if (rawState[name] === value) {
       return;
     }
 
-    if (!this.am_) {
+    if (!this.___dirty) {
       // 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.am_ = true; // Mark the component state as dirty (i.e. modified)
-      this.ax_ = rawState;
-      this.B_ = rawState = extend({}, rawState);
-      this.aw_ = {};
-      this.t_.ar_();
+      this.___dirty = true; // Mark the component state as dirty (i.e. modified)
+      this.___old = rawState;
+      this.___raw = rawState = extend({}, rawState);
+      this.___changes = {};
+      this.___component.___queueUpdate();
     }
 
-    this.aw_[name] = value;
+    this.___changes[name] = value;
 
     if (value === undefined) {
       // Don't store state properties with an undefined or null value
@@ -94,7 +94,7 @@ State.prototype = {
     }
   },
   toJSON: function () {
-    return this.B_;
+    return this.___raw;
   }
 };
 

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

@@ -1,6 +1,6 @@
 "use strict";var eventDelegation = require("./event-delegation");
-var delegateEvent = eventDelegation.aT_;
-var getEventFromEl = eventDelegation.aU_;
+var delegateEvent = eventDelegation.___delegateEvent;
+var getEventFromEl = eventDelegation.___getEventFromEl;
 
 // 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.s_;
+      var out = componentsContext.___out;
       var data = out.data;
 
-      var attachTargets = data.aV_;
+      var attachTargets = data.___attachTargets;
       if (!attachTargets) {
-        attachTargets = data.aV_ = [];
-        out.on("aQ_", function () {
+        attachTargets = data.___attachTargets = [];
+        out.on("___componentsInitialized", 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.aW_ = handleNodeAttach;
-eventDelegation.ao_ = handleNodeDetach;
+eventDelegation.___handleNodeAttach = handleNodeAttach;
+eventDelegation.___handleNodeDetach = handleNodeDetach;

package/dist/runtime/components/defineComponent.js

@@ -5,7 +5,7 @@ var BaseComponent = require("./Component");
 var BaseState = require("./State");
 
 module.exports = function defineComponent(def, renderer) {
-  if (def.y_) {
+  if (def.___isComponent) {
     return def;
   }
 
@@ -34,7 +34,7 @@ module.exports = function defineComponent(def, renderer) {
     BaseComponent.call(this, id);
   }
 
-  if (!proto.y_) {
+  if (!proto.___isComponent) {
     // Inherit from Component if they didn't already
     inherit(ComponentClass, BaseComponent);
   }
@@ -47,14 +47,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.y_ = true;
+  Component.___isComponent = true;
 
   function State(component) {
     BaseState.call(this, component);
   }
   inherit(State, BaseState);
-  proto.Q_ = State;
-  proto.R_ = renderer;
+  proto.___State = State;
+  proto.___renderer = renderer;
 
   return Component;
 };

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

@@ -1,8 +1,8 @@
 "use strict";module.exports = {
-  _M_: new WeakMap(),
-  _L_: new WeakMap(),
-  _q_: new WeakMap(),
-  aX_: new WeakMap(),
-  _o_: new WeakMap(),
-  _p_: {}
+  ___vPropsByDOMNode: new WeakMap(),
+  ___vElementByDOMNode: new WeakMap(),
+  ___componentByDOMNode: new WeakMap(),
+  ___detachedByDOMNode: new WeakMap(),
+  ___keyByDOMNode: new WeakMap(),
+  ___ssrKeyedElementsByComponentId: {}
 };

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

@@ -1,7 +1,7 @@
 "use strict";var componentsUtil = require("@internal/components-util");
-var runtimeId = componentsUtil._Q_;
-var componentLookup = componentsUtil._m_;
-var getMarkoPropsFromEl = componentsUtil._s_;
+var runtimeId = componentsUtil.___runtimeId;
+var componentLookup = componentsUtil.___componentLookup;
+var getMarkoPropsFromEl = componentsUtil.___getMarkoPropsFromEl;
 
 var TEXT_NODE = 3;
 
@@ -54,7 +54,7 @@ function delegateEvent(node, eventName, target, event) {
 
   if (extraArgs != null) {
     if (typeof extraArgs === "number") {
-      extraArgs = targetComponent.Z_[extraArgs];
+      extraArgs = targetComponent.___bubblingDomEvents[extraArgs];
     }
   }
 
@@ -132,12 +132,12 @@ function addDelegatedEventHandlerToHost(eventType, host) {
 
 function noop() {}
 
-exports.aW_ = noop;
-exports.ao_ = noop;
-exports.aT_ = delegateEvent;
-exports.aU_ = getEventFromEl;
-exports._t_ = addDelegatedEventHandler;
-exports._B_ = function (host) {
+exports.___handleNodeAttach = noop;
+exports.___handleNodeDetach = noop;
+exports.___delegateEvent = delegateEvent;
+exports.___getEventFromEl = getEventFromEl;
+exports.___addDelegatedEventHandler = addDelegatedEventHandler;
+exports.___init = 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.y_) {
+  if (def.___isComponent) {
     return def;
   }