marko 4.24.6 → 4.26.0

package/dist/{runtime/components/legacy/defineWidget-legacy-browser.js → node_modules/@internal/components-define-widget-legacy/index-browser.js}

@@ -4,8 +4,8 @@
 var BaseState;
 var BaseComponent;
 var inherit;
-var jQuery = require("../jquery");
-var ready = require("../ready");
+var jQuery = require("../../../runtime/components/jquery");
+var ready = require("../../../runtime/components/ready");
 
 var complain;
 var stateToJSONDef = {
@@ -19,7 +19,7 @@ function noop() {}
 module.exports = function defineWidget(def, renderer) {
   def = def.Widget || def;
 
-  if (def._d_) {
+  if (def.A_) {
     return def;
   }
 
@@ -49,7 +49,7 @@ module.exports = function defineWidget(def, renderer) {
     BaseComponent.call(this, id, doc);
   }
 
-  if (!proto._d_) {
+  if (!proto.A_) {
     // Inherit from Component if they didn't already
     ComponentClass.prototype = Object.create(BaseComponent.prototype);
     for (var propName in proto) {
@@ -62,16 +62,16 @@ module.exports = function defineWidget(def, renderer) {
   // The same prototype will be used by our constructor after
   // we he have set up the prototype chain using the inherit function
   proto = Component.prototype = ComponentClass.prototype;
-  proto.ar_ = true;
+  proto.B_ = true;
 
   proto.constructor = def.constructor = Component;
 
   Object.defineProperty(proto, "state", {
     get: function () {
-      var raw = this.P_ && this.P_._z_;
+      var raw = this.C_ && this.C_.D_;
 
       if (raw && !raw.toJSON) {
-        Object.defineProperty(this.P_._z_, "toJSON", stateToJSONDef);
+        Object.defineProperty(this.C_.D_, "toJSON", stateToJSONDef);
       }
 
       return raw;
@@ -87,7 +87,7 @@ module.exports = function defineWidget(def, renderer) {
 
   Object.defineProperty(proto, "__document", {
     get: function () {
-      return this._c_;
+      return this.E_;
       // eslint-disable-next-line no-constant-condition
     }
   });
@@ -95,38 +95,38 @@ module.exports = function defineWidget(def, renderer) {
   Object.defineProperty(proto, "el", {
     get: function () {
 
-      return this.aC_;
+      return this.F_;
       // eslint-disable-next-line no-constant-condition
     }
   });
 
   // get legacy methods
 
-  proto.aD_ = proto.onRender;
+  proto.G_ = proto.onRender;
   Object.defineProperty(proto, "onRender", {
     get: noop,
     set: function (v) {
-      proto.aD_ = v;
+      proto.G_ = v;
     }
   });
 
-  proto.aE_ = proto.onUpdate;
+  proto.H_ = proto.onUpdate;
   Object.defineProperty(proto, "onUpdate", {
     get: function () {
       return modernMountOrUpdate;
     },
     set: function (v) {
-      proto.aE_ = v;
+      proto.H_ = v;
     }
   });
 
-  proto.aF_ = proto.onDestroy;
+  proto.I_ = proto.onDestroy;
   Object.defineProperty(proto, "onDestroy", {
     get: function () {
       return modernOnDestory;
     },
     set: function (v) {
-      proto.aF_ = v;
+      proto.I_ = v;
     }
   });
 
@@ -135,91 +135,91 @@ module.exports = function defineWidget(def, renderer) {
   proto.onMount = modernMountOrUpdate;
 
   if (legacyInit) {
-    proto.aG_ = legacyInit;
+    proto.J_ = legacyInit;
   }
 
   // convert legacy to modern
-  proto.aH_ = proto.update;
+  proto.K_ = proto.update;
   proto.update = function () {
-    if (this.Z_) {
+    if (this.L_) {
 
       this.destroy = modernOnDestory;
       // eslint-disable-next-line no-constant-condition
 
-      this.Z_ = false;
+      this.L_ = false;
     }
-    this.aI_ = true;
-    if (this.aC_) {
+    this.M_ = true;
+    if (this.F_) {
       this.onBeforeUpdate && this.onBeforeUpdate();
     }
 
-    this.aH_();
-    this.aI_ = false;
+    this.K_();
+    this.M_ = false;
   };
 
   function modernMountOrUpdate() {
     var self = this;
-    var el = this.q_["@_wbind"];
-    var prevEl = this.aC_;
+    var el = this.N_["@_wbind"];
+    var prevEl = this.F_;
 
     if (prevEl !== el) {
-      this.aC_ = el;
+      this.F_ = el;
 
       if (prevEl) {
         this.onBeforeDestroy && this.onBeforeDestroy();
-        this.aF_ && this.aF_();
-        this.aJ_ = undefined;
+        this.I_ && this.I_();
+        this.O_ = undefined;
         this.removeAllListeners();
       }
 
       if (el) {
-        this.aG_ && this.aG_(this.widgetConfig || {});
-        this.aD_ && this.aD_({ firstRender: true });
-        this.aJ_ = legacyRender;
+        this.J_ && this.J_(this.widgetConfig || {});
+        this.G_ && this.G_({ firstRender: true });
+        this.O_ = legacyRender;
 
         // eslint-disable-next-line no-constant-condition
         el.__widget = this;
       }
     } else if (el) {
       if (prevEl) {
-        this.aE_ && this.aE_();
+        this.H_ && this.H_();
       }
 
-      if (this.aK_) {
-        this.aD_ && this.aD_({ firstRender: false });
+      if (this.P_) {
+        this.G_ && this.G_({ firstRender: false });
       }
     }
 
-    this.aB_ = this.W_;
-    this.W_ = null;
-    this.aK_ = false;
+    this.Q_ = this.R_;
+    this.R_ = null;
+    this.P_ = false;
   }
 
   function legacyRender() {
-    if (!this.aI_) {
+    if (!this.M_) {
       this.onBeforeUpdate && this.onBeforeUpdate();
     }
 
-    this.aK_ = true;
+    this.P_ = true;
   }
 
   function modernOnDestory() {
-    if (this.aC_) {
+    if (this.F_) {
       this.onBeforeDestroy && this.onBeforeDestroy();
-      this.aF_ && this.aF_();
-      this.aC_ = null;
+      this.I_ && this.I_();
+      this.F_ = null;
     }
   }
 
   // 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() {
     BaseState.apply(this, arguments);
   }
   inherit(State, BaseState);
-  proto._i_ = State;
+  proto.S_ = State;
 
   jQuery.patchComponent(window.$, proto, true /* don't throw error until used if `$` is missing*/
   );
@@ -251,7 +251,7 @@ module.exports = function defineWidget(def, renderer) {
   if (renderer) {
     // Add the rendering related methods as statics on the
     // new component constructor function
-    Component.renderer = proto._t_ = renderer;
+    Component.renderer = proto.T_ = renderer;
     Component.render = renderer.render;
     Component.renderSync = renderer.renderSync;
   }
@@ -263,6 +263,6 @@ module.exports = function defineWidget(def, renderer) {
   return Component;
 };
 
-BaseState = require("../State");
-BaseComponent = require("../Component");
+BaseState = require("../../../runtime/components/State");
+BaseComponent = require("../../../runtime/components/Component");
 inherit = require("raptor-util/inherit");

package/dist/node_modules/@internal/components-define-widget-legacy/index.js

@@ -0,0 +1,18 @@
+module.exports = function defineWidget(def, renderer) {
+  if (def.A_) {
+    return def;
+  }
+
+  if (renderer) {
+    return {
+      A_: true,
+      _isWidget: true,
+      renderer: renderer,
+      render: renderer.render,
+      renderSync: renderer.renderSync,
+      template: renderer.template
+    };
+  } else {
+    return { A_: true, _isWidget: true };
+  }
+};

package/dist/node_modules/@internal/components-define-widget-legacy/package.json

@@ -0,0 +1,11 @@
+{
+  "main": "./index.js",
+  "browser": "./index-browser.js",
+  "exports": {
+    ".": {
+      "worker": "./index.js",
+      "browser": "./index-browser.js",
+      "default": "./index.js"
+    }
+  }
+}

package/dist/node_modules/@internal/components-endComponent/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var ComponentsContext = require("../../../runtime/components/ComponentsContext");
+var getComponentsContext = ComponentsContext.U_;
+
+module.exports = function endComponent(out, componentDef) {
+  if (componentDef.w_) {
+    out.w("<!--" + out.global.runtimeId + "/-->");
+    getComponentsContext(out).y_ = componentDef.z_;
+  }
+};

package/dist/node_modules/@internal/components-endComponent/package.json

@@ -0,0 +1,11 @@
+{
+  "main": "./index.js",
+  "browser": "./index-browser.js",
+  "exports": {
+    ".": {
+      "worker": "./index.js",
+      "browser": "./index-browser.js",
+      "default": "./index.js"
+    }
+  }
+}

package/dist/node_modules/@internal/components-entry/index-browser.js

@@ -0,0 +1,9 @@
+var registry = require("@internal/components-registry");
+
+exports.getComponentForEl = require("@internal/components-util").V_;
+exports.init = registry.W_;
+exports.register = function (id, component) {
+  registry.r(id, function () {
+    return component;
+  });
+};

package/dist/node_modules/@internal/components-entry/index.js

@@ -0,0 +1,285 @@
+"use strict";
+
+var warp10 = require("warp10");
+var safeJSONRegExp = /<\/|\u2028|\u2029/g;
+var IGNORE_GLOBAL_TYPES = new Set(["undefined", "function", "symbol"]);
+var DEFAULT_RUNTIME_ID = "M";
+
+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;
+
+function safeJSONReplacer(match) {
+  if (match === "</") {
+    return "\\u003C/";
+  } else {
+    return "\\u" + match.charCodeAt(0).toString(16);
+  }
+}
+
+function isNotEmpty(obj) {
+  var keys = Object.keys(obj);
+  for (var i = keys.length; i--;) {
+    if (obj[keys[i]] !== undefined) {
+      return true;
+    }
+  }
+
+  return false;
+}
+function safeStringify(data) {
+  return JSON.stringify(warp10.stringifyPrepare(data)).replace(safeJSONRegExp, safeJSONReplacer);
+}
+
+function getSerializedGlobals($global) {
+  let serializedGlobalsLookup = $global.serializedGlobals;
+  if (serializedGlobalsLookup) {
+    let serializedGlobals;
+    let keys = Object.keys(serializedGlobalsLookup);
+    for (let i = keys.length; i--;) {
+      let key = keys[i];
+      if (serializedGlobalsLookup[key]) {
+        let value = $global[key];
+        if (!IGNORE_GLOBAL_TYPES.has(typeof value)) {
+          if (serializedGlobals === undefined) {
+            serializedGlobals = {};
+          }
+          serializedGlobals[key] = value;
+        }
+      }
+    }
+
+    return serializedGlobals;
+  }
+}
+
+function addComponentsFromContext(componentsContext, componentsToHydrate) {
+  var components = componentsContext.t_;
+
+  var len = components.length;
+
+  for (var i = 0; i < len; i++) {
+    var componentDef = components[i];
+    var id = componentDef.id;
+    var component = componentDef.v_;
+    var flags = componentDef.x_;
+    var isLegacy = componentDef.B_;
+
+    var state = component.state;
+    var input = component.input || 0;
+    var typeName = component.typeName;
+    var customEvents = component.X_;
+    var scope = component.Y_;
+    var bubblingDomEvents = component.Z_;
+
+    var needsState;
+    var serializedProps;
+    var renderBody;
+
+    if (isLegacy) {
+      flags |= FLAG_IS_LEGACY;
+      renderBody = component.___;
+
+      if (component.widgetConfig && isNotEmpty(component.widgetConfig)) {
+        serializedProps = component.widgetConfig;
+      }
+
+      needsState = true;
+    } else {
+      if (input && input.renderBody) {
+        renderBody = input.renderBody;
+        input.renderBody = undefined;
+      }
+
+      if (!(flags & FLAG_WILL_RERENDER_IN_BROWSER) || flags & FLAG_OLD_HYDRATE_NO_CREATE) {
+        component.C_ = undefined; // We don't use `delete` to avoid V8 deoptimization
+        component.R_ = undefined; // We don't use `delete` to avoid V8 deoptimization
+        component.typeName = undefined;
+        component.id = undefined;
+        component.X_ = undefined;
+        component.Y_ = undefined;
+        component.Z_ = undefined;
+        component._a_ = undefined;
+        component._b_ = undefined;
+        component._c_ = undefined;
+
+        needsState = true;
+
+        if (isNotEmpty(component)) {
+          serializedProps = component;
+        }
+      }
+    }
+
+    var undefinedPropNames = undefined;
+
+    if (needsState && state) {
+      // Update state properties with an `undefined` value to have a `null`
+      // value so that the property name will be serialized down to the browser.
+      // This ensures that we add the proper getter/setter for the state property.
+      const stateKeys = Object.keys(state);
+      for (let i = stateKeys.length; i--;) {
+        const stateKey = stateKeys[i];
+
+        if (state[stateKey] === undefined) {
+          if (undefinedPropNames) {
+            undefinedPropNames.push(stateKey);
+          } else {
+            undefinedPropNames = [stateKey];
+          }
+        }
+      }
+    }
+
+    if (typeof renderBody === "function") {
+      flags |= FLAG_HAS_RENDER_BODY;
+      renderBody = undefined;
+    }
+
+    var extra = {
+      b: bubblingDomEvents,
+      d: componentDef._d_,
+      e: customEvents,
+      f: flags || undefined,
+      p: customEvents && scope, // Only serialize scope if we need to attach custom events
+      s: needsState && state,
+      u: undefinedPropNames,
+      w: serializedProps,
+      r: renderBody
+    };
+
+    var parts = [id, typeName];
+    var hasExtra = isNotEmpty(extra);
+
+    if (input) {
+      parts.push(input);
+
+      if (hasExtra) {
+        parts.push(extra);
+      }
+    } else if (hasExtra) {
+      parts.push(0, extra); // empty input;
+    }
+
+    componentsToHydrate.push(parts);
+  }
+
+  components.length = 0;
+
+  // Also add any components from nested contexts
+  var nestedContexts = componentsContext._e_;
+  if (nestedContexts !== undefined) {
+    nestedContexts.forEach(function (nestedContext) {
+      addComponentsFromContext(nestedContext, componentsToHydrate);
+    });
+  }
+}
+
+function getInitComponentsData(out, componentDefs) {
+  const len = componentDefs.length;
+  const $global = out.global;
+  const isLast = $global.f_;
+  const didSerializeComponents = $global._f_;
+  const prefix = $global.componentIdPrefix || $global.widgetIdPrefix;
+
+  if (len === 0) {
+    if (isLast && didSerializeComponents) {
+      return { p: prefix, l: 1 };
+    }
+
+    return;
+  }
+
+  const TYPE_INDEX = 1;
+  const typesLookup = $global._g_ || ($global._g_ = new Map());
+  let newTypes;
+
+  for (let i = 0; i < len; i++) {
+    const componentDef = componentDefs[i];
+    const typeName = componentDef[TYPE_INDEX];
+    let typeIndex = typesLookup.get(typeName);
+
+    if (typeIndex === undefined) {
+      typeIndex = typesLookup.size;
+      typesLookup.set(typeName, typeIndex);
+
+      if (newTypes) {
+        newTypes.push(typeName);
+      } else {
+        newTypes = [typeName];
+      }
+    }
+
+    componentDef[TYPE_INDEX] = typeIndex;
+  }
+
+  let serializedGlobals;
+
+  if (!didSerializeComponents) {
+    $global._f_ = true;
+    serializedGlobals = getSerializedGlobals($global);
+  }
+
+  return {
+    p: prefix,
+    l: isLast && 1,
+    g: serializedGlobals,
+    w: componentDefs,
+    t: newTypes
+  };
+}
+
+function getInitComponentsDataFromOut(out) {
+  const componentsContext = out.t_;
+
+  if (componentsContext === null) {
+    return;
+  }
+
+  const $global = out.global;
+  const runtimeId = $global.runtimeId;
+  const componentsToHydrate = [];
+  addComponentsFromContext(componentsContext, componentsToHydrate);
+
+  $global.f_ = true;
+  const data = getInitComponentsData(out, componentsToHydrate);
+  $global.f_ = undefined;
+
+  if (runtimeId !== DEFAULT_RUNTIME_ID && data) {
+    data.r = runtimeId;
+  }
+
+  return data;
+}
+
+function writeInitComponentsCode(out) {
+  out.script(exports._h_(out));
+}
+
+exports._h_ = function getInitComponentsCode(out, componentDefs) {
+  const initComponentsData = arguments.length === 2 ? getInitComponentsData(out, componentDefs) : getInitComponentsDataFromOut(out);
+
+  if (initComponentsData === undefined) {
+    return "";
+  }
+
+  const runtimeId = out.global.runtimeId;
+  const componentGlobalKey = runtimeId === DEFAULT_RUNTIME_ID ? "MC" : runtimeId + "_C";
+
+  return `$${componentGlobalKey}=(window.$${componentGlobalKey}||[]).concat(${safeStringify(initComponentsData)})`;
+};
+
+exports._i_ = addComponentsFromContext;
+exports.writeInitComponentsCode = writeInitComponentsCode;
+
+/**
+ * Returns an object that can be sent to the browser using JSON.stringify. The parsed object should be
+ * passed to require('marko-components').initComponents(...);
+ *
+ * @param  {ComponentsContext|AsyncWriter} componentsContext A ComponentsContext or an AsyncWriter
+ * @return {Object} An object with information about the rendered components that can be serialized to JSON. The object should be treated as opaque
+ */
+exports.getRenderedComponents = function (out) {
+  return warp10.stringifyPrepare(getInitComponentsDataFromOut(out));
+};

package/dist/node_modules/@internal/components-entry/package.json

@@ -0,0 +1,11 @@
+{
+  "main": "./index.js",
+  "browser": "./index-browser.js",
+  "exports": {
+    ".": {
+      "worker": "./index.js",
+      "browser": "./index-browser.js",
+      "default": "./index.js"
+    }
+  }
+}

package/dist/{runtime/components/legacy → node_modules/@internal/components-entry-legacy}/index-browser.js

@@ -1,24 +1,23 @@
-var modernMarko = require("../");
-var Component = require("../Component");
-var loader = require("../../../loader");
+var Component = require("../../../runtime/components/Component");
+var loader = require("@internal/loader");
+var getComponentForEl = require("@internal/components-util").V_;
 
 var complain;
 
 // expose legacy
-require("../registry-browser").aO_ = exports;
+require("@internal/components-registry")._j_ = exports;
 exports.load = function (typeName) {
   return exports.defineWidget(loader(typeName));
 };
 
 // legacy api
-exports.defineComponent = require("./defineComponent-legacy");
-exports.defineWidget = require("./defineWidget-legacy");
-exports.defineRenderer = require("./defineRenderer-legacy");
-exports.makeRenderable = exports.renderable = require("../../renderable");
+exports.defineComponent = require("../../../runtime/components/legacy/defineComponent-legacy");
+exports.defineWidget = require("@internal/components-define-widget-legacy");
+exports.defineRenderer = require("../../../runtime/components/legacy/defineRenderer-legacy");
+exports.makeRenderable = exports.renderable = require("../../../runtime/renderable");
 
 // browser only
 var Widget = exports.Widget = Component;
-exports.onInitWidget = modernMarko.onInitComponent;
 exports.getWidgetForEl = exports.get = function (elOrId) {
   var el = elOrId;
 
@@ -30,16 +29,16 @@ exports.getWidgetForEl = exports.get = function (elOrId) {
     return el.__widget;
   }
 
-  return modernMarko.getComponentForEl(el);
+  return getComponentForEl(el);
 };
-exports.initWidgets = modernMarko.init;
+exports.initWidgets = require("@internal/components-registry").W_;
 
 // monkey patch Widget
 if (Widget) {
   var WidgetProto = Widget.prototype;
   WidgetProto.setProps = function (newInput) {
-    this.aA_ = true;
-    this._m_(newInput);
+    this._k_ = true;
+    this._l_(newInput);
   };
   WidgetProto.rerender = function (newInput) {
     if (newInput) {
@@ -51,7 +50,7 @@ if (Widget) {
   };
 }
 
-var RenderResult = require("../../RenderResult");
+var RenderResult = require("../../../runtime/RenderResult");
 
 RenderResult.prototype.getWidget = function () {
   return this.getWidgets()[0];
@@ -59,7 +58,7 @@ RenderResult.prototype.getWidget = function () {
 };
 RenderResult.prototype.getWidgets = function () {
   return RenderResult.prototype.getComponents.apply(this, arguments).filter(function (component) {
-    return component.ar_;
+    return component.B_;
   });
   // eslint-disable-next-line no-constant-condition
 };

package/dist/node_modules/@internal/components-entry-legacy/index.js

@@ -0,0 +1,14 @@
+var modernMarko = require("@internal/components-entry");
+
+// legacy api
+exports.defineComponent = require("../../../runtime/components/legacy/defineComponent-legacy");
+exports.defineWidget = require("@internal/components-define-widget-legacy");
+exports.defineRenderer = require("../../../runtime/components/legacy/defineRenderer-legacy");
+exports.makeRenderable = exports.renderable = require("../../../runtime/renderable");
+
+// server only
+exports.writeInitWidgetsCode = modernMarko.writeInitComponentsCode;
+exports.getRenderedWidgets = exports.getRenderedWidgetIds = modernMarko.getRenderedComponents;
+exports.getInitWidgetsCode = function (out) {
+  return modernMarko._h_(out);
+};