marko 5.29.1 → 5.30.0

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

@@ -0,0 +1,230 @@
+"use strict";var getComponentsContext =
+require("../ComponentsContext").e_;
+var componentsUtil = require("@internal/components-util");
+var componentLookup = componentsUtil._o_;
+var registry = require("@internal/components-registry");
+var modernRenderer = require("../renderer");
+var resolveComponentKey = modernRenderer.aU_;
+var trackAsyncComponents = modernRenderer.aY_;
+var beginComponent = require("@internal/components-beginComponent");
+var endComponent = require("@internal/components-endComponent");
+
+
+function createRendererFunc(templateRenderFunc, componentProps) {
+  var typeName = componentProps.t;
+  //var assignedId = componentProps.id;
+  var isSplit = componentProps.s === true;
+  var isImplicit = componentProps.i === true;
+
+  return function renderer(input, out, assignedId, renderingLogic) {
+    trackAsyncComponents(out);
+
+    var componentsContext = getComponentsContext(out);
+    var parentLegacyComponentDef = componentsContext.aZ_;
+
+    if (isImplicit && parentLegacyComponentDef) {
+      templateRenderFunc(
+      input,
+      out,
+      parentLegacyComponentDef,
+      parentLegacyComponentDef.i_,
+      parentLegacyComponentDef.i_.aA_,
+      out.global);
+
+      return;
+    }
+
+    var widgetBody = input.renderBody;
+    var widgetState = input.widgetState;
+    var widgetConfig = input.widgetConfig;
+    var globalComponentsContext = componentsContext.f_;
+    var component = globalComponentsContext.ax_;
+
+    var isRerender = component !== undefined;
+    var id = assignedId;
+    var isExisting;
+    var parentComponentDef = componentsContext.k_;
+    var ownerComponentDef = out.h_;
+    var ownerComponentId = ownerComponentDef && ownerComponentDef.id;
+    var key = out.j_;
+    var customEvents = out.b__;
+
+    out.h_ = null;
+
+    if (component) {
+      id = component.id;
+      isExisting = true;
+      globalComponentsContext.ax_ = null;
+    } else {
+      if (key != null) {
+        id = id || resolveComponentKey(key.toString(), parentComponentDef);
+      } else if (parentComponentDef) {
+        id = parentComponentDef.aL_();
+      } else {
+        id = globalComponentsContext.aL_();
+      }
+    }
+
+    if (registry._L_ && typeName) {
+      if (renderingLogic) delete renderingLogic.onRender;
+      component = registry._I_(
+      renderingLogic,
+      id,
+      input,
+      out,
+      typeName,
+      customEvents,
+      ownerComponentId);
+
+      if (isSplit || widgetState) {
+        component.input = null;
+      } else if (input.widgetProps) {
+        // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+        component.input = input.widgetProps;
+      }
+    } else {
+      if (!component) {
+        if (isRerender) {
+          // Look in in the DOM to see if a component with the same ID and type already exists.
+          component = componentLookup[id];
+          if (component && component._s_ !== typeName) {
+            component = undefined;
+          }
+        }
+
+        if (component) {
+          isExisting = true;
+        } else {
+          isExisting = false;
+          // We need to create a new instance of the component
+          if (typeName) {
+            component = registry._I_(typeName, id);
+          }
+        }
+      }
+    }
+
+    var isFakeComponent = false;
+
+    if (!component) {
+      isFakeComponent = true;
+      component = {
+        id: id,
+        l_: {}
+      };
+    } else {
+      component._f_ = true;
+
+      if (widgetState) {
+        component.state = widgetState;
+      }
+    }
+
+    component.widgetConfig = widgetConfig;
+    component._c_ = widgetBody || component._c_;
+
+    var componentDef = beginComponent(
+    componentsContext,
+    component,
+    key,
+    ownerComponentDef,
+    isSplit,
+    isFakeComponent);
+
+    componentsContext.aZ_ = componentDef;
+
+    // This is a hack, but we have to swap out the component instance stored with this node
+    var vComponentNode = out.m_;
+
+    componentDef.i_ = isFakeComponent ? null : component;
+    componentDef._w_ = isExisting;
+    componentDef.F_ = true;
+
+    componentDef.t = function (typeName) {
+      if (typeName) {
+        if (registry._L_) {
+          var oldComponent = component;
+          if (renderingLogic) delete renderingLogic.onRender;
+          component = registry._I_(
+          renderingLogic || {},
+          id,
+          input,
+          out,
+          typeName,
+          customEvents,
+          ownerComponentId);
+
+          if (isSplit || widgetState) {
+            component.input = null;
+          } else if (input.widgetProps) {
+            // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+            component.input = input.widgetProps;
+          }
+          Object.assign(component, oldComponent);
+          beginComponent(
+          componentsContext,
+          component,
+          key,
+          ownerComponentDef,
+          isSplit,
+          false,
+          this);
+
+        } else {
+          vComponentNode.i_ = component = registry._I_(
+          typeName,
+          component.id);
+
+        }
+        this.i_ = component;
+      }
+
+      return component;
+    };
+
+    if (!registry._L_) {
+      component.R_ && component.R_();
+    }
+
+    // Render the template associated with the component using the final template
+    // data that we constructed
+    templateRenderFunc(
+    input,
+    out,
+    componentDef,
+    component,
+    component.aA_,
+    out.global);
+
+
+    if (customEvents && componentDef.i_) {
+      if (registry._L_) {
+        componentDef.___ = customEvents;
+        componentDef._a_ = ownerComponentId;
+      } else {
+        componentDef.i_.aB_(
+        customEvents,
+        ownerComponentId);
+
+      }
+    }
+
+    endComponent(out, componentDef);
+    componentsContext.k_ = parentComponentDef;
+    componentsContext.aZ_ = parentLegacyComponentDef;
+  };
+}
+
+module.exports = createRendererFunc;

package/dist/runtime/components/renderer.js

@@ -1,11 +1,11 @@
 "use strict";var componentsUtil = require("@internal/components-util");
-var componentLookup = componentsUtil.T_;
+var componentLookup = componentsUtil._o_;
 
 var ComponentsContext = require("./ComponentsContext");
 var getComponentsContext = ComponentsContext.e_;
 var registry = require("@internal/components-registry");
 var copyProps = require("raptor-util/copyProps");
-var isServer = componentsUtil._r_ === true;
+var isServer = componentsUtil._L_ === true;
 var beginComponent = require("@internal/components-beginComponent");
 var endComponent = require("@internal/components-endComponent");
 
@@ -15,7 +15,7 @@ function resolveComponentKey(key, parentComponentDef) {
   if (key[0] === "#") {
     return key.substring(1);
   } else {
-    return parentComponentDef.id + "-" + parentComponentDef.av_(key);
+    return parentComponentDef.id + "-" + parentComponentDef.aK_(key);
   }
 }
 
@@ -42,7 +42,7 @@ function handleBeginAsync(event) {
   asyncOut.c(
   parentOut.h_,
   parentOut.j_,
-  parentOut.aF_);
+  parentOut.b__);
 
 }
 
@@ -82,7 +82,7 @@ renderingLogic)
     var componentsContext = getComponentsContext(out);
     var globalComponentsContext = componentsContext.f_;
 
-    var component = globalComponentsContext.ah_;
+    var component = globalComponentsContext.ax_;
     var isRerender = component !== undefined;
     var id;
     var isExisting;
@@ -97,7 +97,7 @@ renderingLogic)
       // the top-level UI component as part of a re-render
       id = component.id; // We will use the ID of the component being re-rendered
       isExisting = true; // This is a re-render so we know the component is already in the DOM
-      globalComponentsContext.ah_ = null;
+      globalComponentsContext.ax_ = null;
     } else {
       // Otherwise, we are rendering a nested UI component. We will need
       // to match up the UI component with the component already in the
@@ -106,15 +106,15 @@ renderingLogic)
       // that were provided.
       if (parentComponentDef) {
         // console.log('componentArgs:', componentArgs);
-        customEvents = out.aF_;
+        customEvents = out.b__;
 
         if (key != null) {
           id = resolveComponentKey(key.toString(), parentComponentDef);
         } else {
-          id = parentComponentDef.aw_();
+          id = parentComponentDef.aL_();
         }
       } else {
-        id = globalComponentsContext.aw_();
+        id = globalComponentsContext.aL_();
       }
     }
 
@@ -123,7 +123,7 @@ renderingLogic)
       // we don't need to match up the UI component with a previously
       // rendered component already mounted to the DOM. We also create
       // a lightweight ServerComponent
-      component = registry._o_(
+      component = registry._I_(
       renderingLogic,
       id,
       input,
@@ -135,13 +135,13 @@ renderingLogic)
 
       // This is the final input after running the lifecycle methods.
       // We will be passing the input to the template for the `input` param
-      input = component.M_;
+      input = component._e_;
     } else {
       if (!component) {
         if (
         isRerender && (
         component = componentLookup[id]) &&
-        component.Y_ !== typeName)
+        component._s_ !== typeName)
         {
           // Destroy the existing component since
           component.destroy();
@@ -153,7 +153,7 @@ renderingLogic)
         } else {
           isExisting = false;
           // We need to create a new instance of the component
-          component = registry._o_(typeName, id);
+          component = registry._I_(typeName, id);
 
           if (shouldApplySplitMixins === true) {
             shouldApplySplitMixins = false;
@@ -170,36 +170,36 @@ renderingLogic)
         // Set this flag to prevent the component from being queued for update
         // based on the new input. The component is about to be rerendered
         // so we don't want to queue it up as a result of calling `setInput()`
-        component.N_ = true;
+        component._f_ = true;
 
         if (customEvents !== undefined) {
-          component.am_(customEvents, ownerComponentId);
+          component.aB_(customEvents, ownerComponentId);
         }
 
         if (isExisting === false) {
-          component.ao_(input, out);
+          component.aD_(input, out);
         }
 
-        input = component._Z_(input, onInput, out);
+        input = component._m_(input, onInput, out);
 
         if (isExisting === true) {
           if (
-          component.ab_ === false ||
-          component.shouldUpdate(input, component.J_) === false)
+          component.as_ === false ||
+          component.shouldUpdate(input, component.G_) === false)
           {
             // We put a placeholder element in the output stream to ensure that the existing
             // DOM node is matched up correctly when using morphdom. We flag the VElement
             // node to track that it is a preserve marker
-            out.aG_(component);
+            out.ba_(component);
             globalComponentsContext.z_[id] = true;
-            component._a_(); // The component is no longer dirty so reset internal flags
+            component._v_(); // The component is no longer dirty so reset internal flags
             return;
           }
         }
       }
 
-      component._P_ = out.global;
-      component.ap_(out);
+      component.ai_ = out.global;
+      component.aE_(out);
     }
 
     var componentDef = beginComponent(
@@ -211,7 +211,7 @@ renderingLogic)
     isImplicitComponent);
 
 
-    componentDef._c_ = isExisting;
+    componentDef._w_ = isExisting;
 
     // Render the template associated with the component using the final template
     // data that we constructed
@@ -220,7 +220,7 @@ renderingLogic)
     out,
     componentDef,
     component,
-    component.ak_,
+    component.aA_,
     out.global);
 
 
@@ -229,4 +229,8 @@ renderingLogic)
   };
 }
 
-module.exports = createRendererFunc;
+module.exports = createRendererFunc;
+
+// exports used by the legacy renderer
+createRendererFunc.aU_ = resolveComponentKey;
+createRendererFunc.aY_ = trackAsyncComponents;

package/dist/runtime/components/update-manager.js

@@ -4,7 +4,7 @@ var updatesScheduled = false;
 var batchStack = []; // A stack of batched updates
 var unbatchedQueue = []; // Used for scheduled batched updates
 
-var setImmediate = require("@internal/set-immediate")._I_;
+var setImmediate = require("@internal/set-immediate").ab_;
 
 /**
  * This function is called when we schedule the update of "unbatched"
@@ -41,7 +41,7 @@ function updateComponents(queue) {
   //       since we will still get to them at the end
   for (var i = 0; i < queue.length; i++) {
     var component = queue[i];
-    component.aq_(); // Do the actual component update
+    component.aF_(); // Do the actual component update
   }
 
   // Clear out the queue by setting the length to zero
@@ -54,7 +54,7 @@ function batchUpdate(func) {
   // batched update completes we invoke the "afterUpdate"
   // event listeners.
   var batch = {
-    aH_: null
+    bb_: null
   };
 
   batchStack.push(batch);
@@ -65,8 +65,8 @@ function batchUpdate(func) {
     try {
       // Update all of the components that where queued up
       // in this batch (if any)
-      if (batch.aH_) {
-        updateComponents(batch.aH_);
+      if (batch.bb_) {
+        updateComponents(batch.bb_);
       }
     } finally {
       // Now that we have completed the update of all the components
@@ -89,10 +89,10 @@ function queueComponentUpdate(component) {
     // We default the batch queue to null to avoid creating an Array instance
     // unnecessarily. If it is null then we create a new Array, otherwise
     // we push it onto the existing Array queue
-    if (batch.aH_) {
-      batch.aH_.push(component);
+    if (batch.bb_) {
+      batch.bb_.push(component);
     } else {
-      batch.aH_ = [component];
+      batch.bb_ = [component];
     }
   } else {
     // We are not within a batched update. We need to schedule a batch update
@@ -103,5 +103,5 @@ function queueComponentUpdate(component) {
   }
 }
 
-exports.aa_ = queueComponentUpdate;
-exports.ag_ = batchUpdate;
+exports.ar_ = queueComponentUpdate;
+exports.aw_ = batchUpdate;

package/dist/runtime/createOut.js

@@ -8,6 +8,6 @@ function createOut(globalData) {
   return actualCreateOut(globalData);
 }
 
-createOut.aI_ = setCreateOut;
+createOut.bc_ = setCreateOut;
 
 module.exports = createOut;

package/dist/runtime/dom-insert.js

@@ -1,12 +1,12 @@
 "use strict";var extend = require("raptor-util/extend");
 var componentsUtil = require("@internal/components-util");
-var destroyComponentForNode = componentsUtil._z_;
-var destroyNodeRecursive = componentsUtil._A_;
+var destroyComponentForNode = componentsUtil._T_;
+var destroyNodeRecursive = componentsUtil._U_;
 var helpers = require("./vdom/morphdom/helpers");
 
-var insertBefore = helpers.aJ_;
-var insertAfter = helpers.aK_;
-var removeChild = helpers.aL_;
+var insertBefore = helpers.bd_;
+var insertAfter = helpers.be_;
+var removeChild = helpers.bf_;
 
 function resolveEl(el) {
   if (typeof el == "string") {

package/dist/runtime/helpers/_change-case.js

@@ -6,7 +6,7 @@ var dashToCamelLookup = Object.create(null);
 /**
  * Helper for converting camelCase to dash-case.
  */
-exports.aM_ = function camelToDashCase(name) {
+exports.bg_ = function camelToDashCase(name) {
   var nameDashed = camelToDashLookup[name];
   if (!nameDashed) {
     nameDashed = camelToDashLookup[name] = name.
@@ -24,7 +24,7 @@ exports.aM_ = function camelToDashCase(name) {
 /**
  * Helper for converting dash-case to camelCase.
  */
-exports.aN_ = function dashToCamelCase(name) {
+exports.bh_ = function dashToCamelCase(name) {
   var nameCamel = dashToCamelLookup[name];
   if (!nameCamel) {
     nameCamel = dashToCamelLookup[name] = name.replace(

package/dist/runtime/helpers/dynamic-tag.js

@@ -37,7 +37,7 @@ customEvents)
     var component = componentDef && componentDef.i_;
     if (typeof tag === "string") {
       if (renderBody) {
-        out.aO_(
+        out.bi_(
         tag,
         attrs,
         key,
@@ -45,9 +45,9 @@ customEvents)
         addEvents(componentDef, customEvents, props));
 
         renderBody(out);
-        out.aP_();
+        out.bj_();
       } else {
-        out.aQ_(
+        out.bk_(
         tag,
         attrs,
         key,
@@ -66,10 +66,8 @@ customEvents)
       }
 
       var renderer =
-      tag._ ||
-      tag.render ||
-      tag.renderer && tag.renderer.renderer ||
-      tag.renderer;
+      tag._ || (
+      tag.renderer ? tag.renderer.renderer || tag.renderer : tag.render);
 
       // eslint-disable-next-line no-constant-condition
 
@@ -108,7 +106,7 @@ customEvents)
             var globalContext = componentsContext.f_;
             componentsContext.k_ = new ComponentDef(
             component,
-            parentComponentDef.id + "-" + parentComponentDef.av_(key),
+            parentComponentDef.id + "-" + parentComponentDef.aK_(key),
             globalContext);
 
             render.toJSON = RENDER_BODY_TO_JSON;
@@ -144,7 +142,7 @@ function attrsToCamelCase(attrs) {
   var result = {};
 
   for (var key in attrs) {
-    result[changeCase.aN_(key)] = attrs[key];
+    result[changeCase.bh_(key)] = attrs[key];
   }
 
   return result;

package/dist/runtime/helpers/style-value.js

@@ -14,11 +14,15 @@ module.exports = function styleHelper(style) {
 
   if (type !== "string") {
     var styles = "";
+    var sep = "";
 
     if (Array.isArray(style)) {
       for (var i = 0, len = style.length; i < len; i++) {
         var next = styleHelper(style[i]);
-        if (next) styles += next + (next[next.length - 1] !== ";" ? ";" : "");
+        if (next) {
+          styles += sep + next;
+          sep = ";";
+        }
       }
     } else if (type === "object") {
       for (var name in style) {
@@ -28,7 +32,8 @@ module.exports = function styleHelper(style) {
             value += "px";
           }
 
-          styles += changeCase.aM_(name) + ":" + value + ";";
+          styles += sep + changeCase.bg_(name) + ":" + value;
+          sep = ";";
         }
       }
     }