marko 5.39.2 → 5.39.3

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

@@ -5,7 +5,7 @@
 var ComponentDef = require("../components/ComponentDef");
 var ComponentsContext = require("../components/ComponentsContext");
 var serializeNOOP = require("../helpers/serialize-noop");
-var w10NOOP = serializeNOOP.aL_;
+var w10NOOP = serializeNOOP.aM_;
 var w10ToJSON = serializeNOOP.W_;
 var changeCase = require("./_change-case");
 var getComponentsContext = ComponentsContext.T_;
@@ -37,7 +37,7 @@ customEvents)
     var component = componentDef && componentDef.s_;
     if (typeof tag === "string") {
       if (renderBody) {
-        out.bm_(
+        out.bn_(
           tag,
           attrs,
           key,
@@ -45,9 +45,9 @@ customEvents)
           addEvents(componentDef, customEvents, props)
         );
         renderBody(out);
-        out.bn_();
+        out.bo_();
       } else {
-        out.bo_(
+        out.bp_(
           tag,
           attrs,
           key,
@@ -79,8 +79,8 @@ customEvents)
 
 
 
-      if (dynamicTag.bp_) {
-        renderer = dynamicTag.bp_(
+      if (dynamicTag.bq_) {
+        renderer = dynamicTag.bq_(
           renderer,
           render,
           args,
@@ -91,7 +91,7 @@ customEvents)
       if (renderer) {
         out.c(componentDef, key, customEvents);
         renderer(attrs, out);
-        out.ab_ = null;
+        out.ac_ = null;
       } else {
         var isFn = typeof render === "function";
 
@@ -115,7 +115,7 @@ customEvents)
             var globalContext = componentsContext.p_;
             componentsContext.o_ = new ComponentDef(
               component,
-              parentComponentDef.id + "-" + parentComponentDef.aP_(key),
+              parentComponentDef.id + "-" + parentComponentDef.aQ_(key),
               globalContext
             );
             render.toJSON = w10ToJSON;
@@ -151,7 +151,7 @@ function attrsToCamelCase(attrs) {
   var result = {};
 
   for (var key in attrs) {
-    result[changeCase.bl_(key)] = attrs[key];
+    result[changeCase.bm_(key)] = attrs[key];
   }
 
   return result;

package/dist/runtime/helpers/load-tag-browser.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var createTemplate = require("../vdom").t;
+var getLoadedTemplate =
+require("@internal/components-registry")._K_;
+
+module.exports = function loadTag(typeId, load, trigger) {
+  var loading;
+  var hydratedComponents = new WeakSet();
+  var pending = new Set();
+  var start = trigger ? trigger(load) : load;
+  var lazyTemplate = createTemplate(typeId);
+  // Assumes rendering as a tag (direct or dynamic) — both assign the
+  // component def (`out.c`) before invoking `_`.
+  lazyTemplate._ = function loadRenderer(input, out) {
+    var component = out.ac_.s_;
+    var template = getLoadedTemplate(typeId);
+
+    if (!template) {
+      if (!loading) {
+        loading = start().then(
+          function () {
+            pending = pending.forEach(function (c) {
+              c.J_ ||
+              c._H_(c.P_, true).afterInsert(c.C_);
+            });
+          },
+          function (err) {
+            // Allows a later render to retry the load.
+            var failed = pending;
+            loading = undefined;
+            pending = new Set();
+            failed.forEach(function (c) {
+              c.J_ || c.emit("error", err);
+            });
+          }
+        );
+      }
+      pending.add(component);
+    }
+
+    if (out.b_.p_.ab_) {
+      hydratedComponents.add(component);
+    }
+
+    if (hydratedComponents.has(component)) {
+      out.bf(out.ad_ + "s", component, true).ef();
+    }
+
+    out.bf(out.ad_, component, !template);
+
+    if (template) {
+      template._(input, out);
+    }
+
+    out.ef();
+  };
+  return lazyTemplate;
+};

package/dist/runtime/helpers/load-tag-event-trigger.js

@@ -0,0 +1,25 @@
+"use strict";
+
+module.exports = function loadEventTrigger(event, selector) {
+  var pending;
+  return function (load) {
+    return function () {
+      return (
+      pending || (
+      pending = new Promise(function (resolve) {
+        var el =
+        document.querySelector(selector) || (
+        // eslint-disable-next-line no-constant-binary-expression
+
+
+
+
+
+
+          resolve());
+        if (el) el.addEventListener(event, resolve, { once: true });
+      }))).
+      then(load);
+    };
+  };
+};

package/dist/runtime/helpers/load-tag-idle-trigger.js

@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = function loadIdleTrigger(options) {
+  var pending;
+  return function (load) {
+    return function () {
+      return (
+      pending || (
+      pending = new Promise(function (resolve) {
+        (self.requestIdleCallback || resolve)(resolve, options);
+      }))).
+      then(load);
+    };
+  };
+};

package/dist/runtime/helpers/load-tag-media-trigger.js

@@ -0,0 +1,17 @@
+"use strict";
+
+module.exports = function mediaTrigger(query) {
+  var pending;
+  return function (load) {
+    return function () {
+      return (
+      pending || (
+      pending = new Promise(function (resolve) {
+        var mql = matchMedia(query);
+        if (mql.matches) resolve();else
+        mql.addEventListener("change", resolve, { once: true });
+      }))).
+      then(load);
+    };
+  };
+};

package/dist/runtime/helpers/load-tag-race-trigger.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var noop = function () {
+  return Promise.resolve();
+};
+
+module.exports = function loadRaceTrigger() {
+  var triggers = Array.prototype.slice.call(arguments);
+  var pending;
+  return function (load) {
+    return function () {
+      return (
+      pending || (
+      pending = Promise.race(
+        triggers.map(function (t) {
+          return t(noop)();
+        })
+      ))).
+      then(load);
+    };
+  };
+};

package/dist/runtime/helpers/load-tag-visible-trigger.js

@@ -0,0 +1,35 @@
+"use strict";
+
+module.exports = function loadVisibleTrigger(selector, options) {
+  var pending;
+  return function (load) {
+    return function () {
+      return (
+      pending || (
+      pending = new Promise(function (resolve) {
+        var el =
+        document.querySelector(selector) || (
+        // eslint-disable-next-line no-constant-binary-expression
+
+
+
+
+
+
+          resolve());
+        if (el) {
+          new IntersectionObserver(function (entries, io) {
+            if (
+            entries.some(function (entry) {
+              return entry.isIntersecting;
+            }))
+            {
+              resolve(io.disconnect());
+            }
+          }, options).observe(el);
+        }
+      }))).
+      then(load);
+    };
+  };
+};

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

@@ -0,0 +1,168 @@
+"use strict";
+
+var flushHereAndAfter = require("../../core-tags/core/__flush_here_and_after__");
+var escapeScript = require("../html/helpers/escape-script-placeholder");
+var FLAG_WILL_RERENDER_IN_BROWSER = 1;
+var kAssets = Symbol();
+var kBlockIndex = Symbol();
+var kDeferIndex = Symbol();
+var kOriginal = Symbol();
+var assetFlush;
+
+exports.withPageAssets = function withPageAssets(typeId, template, runtime) {
+  assetFlush = runtime;
+  var render = template[kOriginal] || (template[kOriginal] = template._);
+  var flushBeforeInput = { renderBody: flush };
+  template._ = function (input, out) {
+    var hasAssets = !!out.global[kAssets];
+    var key = out.ad_;
+    var def = out.ac_;
+    var component = def && def.s_;
+    addAsset(out.global, typeId);
+
+    if (hasAssets) {
+      if (willRerender(def)) {
+        out.bf(key + "s", component, true);
+        flush(out);
+        out.ef();
+      } else {
+        flush(out);
+      }
+    } else {
+      flushHereAndAfter(flushBeforeInput, out);
+    }
+
+    render(input, out);
+  };
+  return template;
+};
+
+exports.withLoadAssets = function withLoadAssets(typeId, template, triggers) {
+  if (template[kOriginal]) return template;
+  var render = template[kOriginal] = template._;
+  template._ = function (input, out) {
+    var key = out.ad_;
+    var def = out.ac_;
+    addAsset(out.global, typeId, triggers);
+
+    if (willRerender(def)) {
+      out.bf(key + "s", def.s_, true);
+      flush(out);
+      out.ef();
+      out.bf(key, def.s_, true);
+      render(input, out);
+      out.ef();
+    } else {
+      flush(out);
+      render(input, out);
+    }
+  };
+  return template;
+};
+
+exports.flushHead = function flushHead(out) {
+  if (out.global[kAssets]) {
+    flush(out);
+  }
+};
+
+function willRerender(def) {
+  return def && def.u_ & FLAG_WILL_RERENDER_IN_BROWSER ? true : false;
+}
+
+function flush(out) {
+  var g = out.global;
+  var result = "";
+  var assets = g[kAssets];
+  var length = assets.length;
+  var bi = g[kBlockIndex];
+  var di = g[kDeferIndex];
+
+  for (; bi < length; bi++) {
+    result += assetFlush(g, "block", assets[bi].id);
+  }
+
+  for (; di < length; di++) {
+    var asset = assets[di];
+    var deferHTML = assetFlush(g, "defer", asset.id);
+    if (asset.triggers) {
+      if (deferHTML) out.script(triggerScript(deferHTML, asset.triggers));
+    } else {
+      result += deferHTML;
+    }
+  }
+
+  g[kBlockIndex] = bi;
+  g[kDeferIndex] = di;
+  out.write(result);
+}
+
+function addAsset(g, id, triggers) {
+  var assets = g[kAssets];
+  if (!assets) {
+    g[kAssets] = [{ id: id, triggers: triggers }];
+    g[kBlockIndex] = g[kDeferIndex] = 0;
+  } else if (
+  !assets.find(function (a) {
+    return a.id === id;
+  }))
+  {
+    assets.push({ id: id, triggers: triggers });
+  }
+}
+
+function triggerScript(html, triggers) {
+  var htmlStr = escapeScript(JSON.stringify(html));
+  var exprs = triggers.map(function (trigger) {
+    var options = trigger.options && toObjectExpression(trigger.options);
+    switch (trigger.type) {
+      case "visible":
+        return (
+          "(e=>e&&new IntersectionObserver((e,i)=>e.some(e=>e.isIntersecting)&&i.disconnect()+l()" + (
+          options ? "," + options : "") +
+          ").observe(e))(document.querySelector(" +
+          JSON.stringify(trigger.selector) +
+          ")||l())");
+
+      case "idle":
+        return (
+          "(self.requestIdleCallback||l)(l" + (
+          options ? "," + options : "") +
+          ")");
+
+      case "media":
+        return (
+          '(m=>m.matches?l():m.addEventListener("change",l,{once:1}))(matchMedia(' +
+          JSON.stringify(trigger.selector) +
+          "))");
+
+      default:
+        return (
+          '(e=>e?.addEventListener("' +
+          trigger.type.slice("on-".length) +
+          '",l,{once:1}))(document.querySelector(' +
+          JSON.stringify(trigger.selector) +
+          ")||l())");
+
+    }
+  });
+  return (
+    '((p,h,d,l=$=>d||p.insertAdjacentHTML("afterend",d=h))=>' + (
+    exprs.length > 1 ? "{" + exprs.join(";") + "}" : exprs[0]) +
+    ")(document.currentScript," +
+    htmlStr +
+    ")");
+
+}
+
+function toObjectExpression(options) {
+  var result = "{";
+  var sep = "";
+  for (var key in options) {
+    if (Object.prototype.hasOwnProperty.call(options, key)) {
+      result += sep + JSON.stringify(key) + ":" + JSON.stringify(options[key]);
+      sep = ",";
+    }
+  }
+  return result + "}";
+}

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

@@ -16,5 +16,5 @@ customEvents)
     input,
     out
   );
-  out.ab_ = null;
+  out.ac_ = null;
 };

package/dist/runtime/helpers/serialize-noop.js

@@ -1,5 +1,5 @@
 "use strict";var w10NOOP = require("warp10/constants").NOOP;
-exports.aL_ = w10NOOP;
+exports.aM_ = w10NOOP;
 exports.W_ = function () {
   return w10NOOP;
 };

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

@@ -32,7 +32,7 @@ module.exports = function styleHelper(style) {
             value += "px";
           }
 
-          styles += sep + changeCase.bk_(name) + ":" + value;
+          styles += sep + changeCase.bl_(name) + ":" + value;
           sep = ";";
         }
       }

package/dist/runtime/helpers/tags-compat/runtime-dom.js

@@ -11,10 +11,10 @@ const morphdom = require("../../vdom/morphdom");
 const { _m_ } = require("../../vdom/morphdom/fragment");
 const dynamicTag = require("../dynamic-tag");
 const Component = require("../../components/Component");
-const noopRenderer = require("../serialize-noop").aL_;
+const noopRenderer = require("../serialize-noop").aM_;
 
 exports.p = function (domCompat) {
-  dynamicTag.bp_ = function tagsToVdom(
+  dynamicTag.bq_ = function tagsToVdom(
   renderer,
   renderBody,
   args,
@@ -34,23 +34,23 @@ exports.p = function (domCompat) {
     return renderer;
   };
 
-  Component.prototype.bq_ =
-  Component.prototype.aF_;
-  Component.prototype.aF_ = function (customEvents, scopeId) {
+  Component.prototype.br_ =
+  Component.prototype.aG_;
+  Component.prototype.aG_ = function (customEvents, scopeId) {
     for (const customEvent of customEvents) {
       customEvent[1] = domCompat.resolveRegistered(
         customEvent[1],
-        this.am_
+        this.an_
       );
     }
 
-    this.bq_(customEvents, scopeId);
+    this.br_(customEvents, scopeId);
   };
 
   const defDeserialize = ComponentDef._F_;
   ComponentDef._F_ = function (o, types, global, registry) {
     if (typeof o[2] === "number") {
-      o[2] = self[global.runtimeId][global.renderId].s[o[2]].m5i;
+      o[2] = domCompat.getScope(global, o[2]).m5i;
     }
     return defDeserialize(o, types, global, registry);
   };
@@ -64,7 +64,7 @@ exports.p = function (domCompat) {
 
       out.bf("1", component, !newNode);
       if (newNode) {
-        out.node({ br_: () => newNode });
+        out.node({ bs_: () => newNode });
       }
       out.ef();
     },
@@ -122,6 +122,7 @@ exports.p = function (domCompat) {
             renderAndMorph(scope, rendererFromAnywhere, renderer, input),
             () => _m_()
           );
+          domCompat.setRendererId(newRenderer, renderer);
           rendererCache.set(renderer, newRenderer);
         }
       }
@@ -129,7 +130,6 @@ exports.p = function (domCompat) {
     return newRenderer;
   }
 
-  domCompat.registerRenderer(create5to6Renderer);
   domCompat.init(noopRenderer);
 
   function renderAndMorph(scope, renderer, renderBody, input) {
@@ -137,18 +137,18 @@ exports.p = function (domCompat) {
     let host = domCompat.getStartNode(scope);
     let rootNode = host.fragment;
     if (!rootNode) {
-      const component = scope.bs_ =
+      const component = scope.bt_ =
       _n_[scope.m5c];
       rootNode = component._G_;
       host = rootNode.startNode;
       domCompat.setScopeNodes(host, rootNode.startNode, rootNode.endNode);
     }
-    const existingComponent = scope.bs_;
+    const existingComponent = scope.bt_;
     const componentsContext = T_(out);
     const globalComponentsContext = componentsContext.p_;
     let customEvents;
     let normalizedInput;
-    globalComponentsContext.aB_ = existingComponent;
+    globalComponentsContext.aC_ = existingComponent;
     out.sync();
     if (renderer) {
       const [rawInput] = input;
@@ -174,16 +174,16 @@ exports.p = function (domCompat) {
     }
 
     domCompat.queueEffect(scope, () => {
-      const targetNode = out.aj_().aC_;
+      const targetNode = out.ak_().aD_;
       morphdom(rootNode, targetNode, host, componentsContext);
-      const componentDefs = componentsContext.ah_(
+      const componentDefs = componentsContext.ai_(
         getRootNode(host)
       );
       const component = componentDefs[0].s_;
       component._G_ = rootNode;
       component.P_ = normalizedInput;
       component.X_ = customEvents;
-      scope.bs_ = component;
+      scope.bt_ = component;
     });
   }
 

package/dist/runtime/helpers/tags-compat/runtime-html.js

@@ -81,7 +81,7 @@ exports.p = function (htmlCompat) {
     });
   });
 
-  dynamicTag5.bp_ = function tagsToVdom(
+  dynamicTag5.bq_ = function tagsToVdom(
   tagsRenderer,
   renderBody,
   args)
@@ -230,7 +230,7 @@ exports.p = function (htmlCompat) {
     };
   });
 
-  return htmlCompat.registerRenderer;
+  return htmlCompat.register;
 };
 
 function concatScripts(a, b) {

package/dist/runtime/html/AsyncStream.js

@@ -9,7 +9,7 @@ var markoAttr = require("./helpers/data-marko");
 var escapeXmlHelper = require("./helpers/escape-xml");
 var StringWriter = require("./StringWriter");
 var escapeXmlOrNullish = escapeXmlHelper.x;
-var escapeXmlString = escapeXmlHelper.bt_;
+var escapeXmlString = escapeXmlHelper.bu_;
 var missingSetTimeout = typeof setTimeout !== "function";
 
 function noop() {}
@@ -102,10 +102,10 @@ function AsyncStream(global, writer, parentOut) {
 
   this.b_ = null; // ComponentsContext
 
-  this.ab_ = null;
   this.ac_ = null;
-  this.be_ = null;
-  this.bu_ = false;
+  this.ad_ = null;
+  this.bf_ = null;
+  this.bv_ = false;
 }
 
 AsyncStream.DEFAULT_TIMEOUT = 10000;
@@ -126,11 +126,11 @@ AsyncStream.enableAsyncStackTrace = function () {
 var proto = AsyncStream.prototype = {
   constructor: AsyncStream,
   C_: typeof document === "object" && document,
-  bv_: true,
+  bw_: true,
 
   [Symbol.asyncIterator]() {
-    if (this.bw_) {
-      return this.bw_;
+    if (this.bx_) {
+      return this.bx_;
     }
 
     const originalWriter = this._state.writer;
@@ -222,7 +222,7 @@ var proto = AsyncStream.prototype = {
       };
     }
 
-    return this.bw_ = {
+    return this.bx_ = {
       next: iteratorNextFn,
       return: iteratorReturnFn,
       throw: iteratorReturnFn,
@@ -279,7 +279,7 @@ var proto = AsyncStream.prototype = {
     return this;
   },
 
-  aj_: function () {
+  ak_: function () {
     return this._state.writer.toString();
   },
 
@@ -287,7 +287,7 @@ var proto = AsyncStream.prototype = {
    * Legacy...
    */
   getOutput: function () {
-    return this.aj_();
+    return this.ak_();
   },
 
   toString: function () {
@@ -345,7 +345,7 @@ var proto = AsyncStream.prototype = {
           }
 
           this._lastCount++;
-          newStream.bu_ = true;
+          newStream.bv_ = true;
         }
 
         name = options.name;
@@ -465,7 +465,7 @@ var proto = AsyncStream.prototype = {
         parentOut._handleChildDone(this);
       }
     } else {
-      if (childOut.bu_) {
+      if (childOut.bv_) {
         this._lastCount--;
       }
 
@@ -645,7 +645,7 @@ var proto = AsyncStream.prototype = {
     return newOut;
   },
 
-  bo_: function (
+  bp_: function (
   tagName,
   elementAttrs,
   key,
@@ -684,7 +684,7 @@ var proto = AsyncStream.prototype = {
     this.write(str);
   },
 
-  bm_: function (
+  bn_: function (
   name,
   elementAttrs,
   key,
@@ -750,13 +750,13 @@ var proto = AsyncStream.prototype = {
     }
   },
 
-  ai_: function (host) {
+  aj_: function (host) {
     var node = this._node;
 
     if (!node) {
       var nextEl;
       var fragment;
-      var html = this.aj_();
+      var html = this.ak_();
       if (!host) host = this.C_;
       var doc = host.ownerDocument || host;
 
@@ -802,15 +802,15 @@ var proto = AsyncStream.prototype = {
   },
 
   c: function (componentDef, key, customEvents) {
-    this.ab_ = componentDef;
-    this.ac_ = key;
-    this.be_ = customEvents;
+    this.ac_ = componentDef;
+    this.ad_ = key;
+    this.bf_ = customEvents;
   }
 };
 
 // alias:
 proto.w = proto.write;
-proto.bn_ = proto.endElement;
+proto.bo_ = proto.endElement;
 
 module.exports = AsyncStream;