marko 5.33.3 → 5.33.5

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

@@ -0,0 +1 @@
+"use strict";require("./runtime-dom.js").p(require("@marko/runtime-tags/debug/dom").compat);

package/dist/runtime/helpers/tags-compat/dom-debug.mjs

@@ -0,0 +1,3 @@
+import { compat } from "@marko/runtime-tags/debug/dom";
+import { p } from "./runtime-dom.js";
+p(compat);

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

@@ -0,0 +1 @@
+"use strict";require("./runtime-dom.js").p(require("@marko/runtime-tags/dom").compat);

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

@@ -0,0 +1,3 @@
+import { compat } from "@marko/runtime-tags/dom";
+import { p } from "./runtime-dom.js";
+p(compat);

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

@@ -0,0 +1,3 @@
+"use strict";exports.s = require("./runtime-html.js").p(
+  require("@marko/runtime-tags/debug/html")
+);

package/dist/runtime/helpers/tags-compat/html-debug.mjs

@@ -0,0 +1,3 @@
+import * as api from "@marko/runtime-tags/debug/html";
+import { p } from "./runtime-html.js";
+export const s = p(api);

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

@@ -0,0 +1 @@
+"use strict";exports.s = require("./runtime-html.js").p(require("@marko/runtime-tags/html"));

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

@@ -0,0 +1,3 @@
+import * as api from "@marko/runtime-tags/html";
+import { p } from "./runtime-html.js";
+export const s = p(api);

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

@@ -0,0 +1,231 @@
+"use strict";const { _i_ } = require("@internal/components-util");
+const {
+  R_
+} = require("../../components/ComponentsContext");
+const defineComponent = require("../../components/defineComponent");
+const { r: registerComponent } = require("../../components/registry");
+const createRenderer = require("../../components/renderer");
+const defaultCreateOut = require("../../createOut");
+const morphdom = require("../../vdom/morphdom");
+const { _h_ } = require("../../vdom/morphdom/fragment");
+const dynamicTag = require("../dynamic-tag");
+
+exports.p = function (domCompat) {
+  dynamicTag.bk_ = function tagsToVdom(
+  renderer,
+  renderBody,
+  args)
+  {
+    const tagsRenderer = domCompat.resolveRenderer(renderer || renderBody);
+
+    if (tagsRenderer) {
+      return (input, out) =>
+      TagsCompat({ i: args ? args : input, r: tagsRenderer }, out);
+    }
+
+    return renderer;
+  };
+
+  const TagsCompatId = "tags-compat";
+  const TagsCompat = createRenderer(
+    function (_, out, componentDef, component) {
+      const isHydrate =
+      R_(out).o_._W_;
+      const input = Array.isArray(_.i) ? _.i : [_.i];
+      const tagsRenderer = domCompat.resolveRenderer(_.r);
+      const newNode = domCompat.render(
+        isHydrate,
+        out,
+        component,
+        tagsRenderer,
+        input
+      );
+
+      out.bf(out._Y_, component, !newNode);
+      if (newNode) {
+        out.node({ bl_: () => newNode });
+      }
+      out.ef();
+    },
+    // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+    {
+      t: TagsCompatId
+    },
+    {}
+  );
+
+  registerComponent(TagsCompatId, () => ({
+    _: TagsCompat,
+    Component: defineComponent(
+      {
+        onMount: domCompat.runComponentEffects,
+        onUpdate: domCompat.runComponentEffects
+      },
+      TagsCompat
+    )
+  }));
+
+  // (
+  //   nodeAccessor: Accessor,
+  //   dynamicTagAttrs?: IntersectionSignal,
+  //   intersection?: IntersectionSignal,
+  //   valueWithIntersection?: ValueSignal
+  // )
+
+  const rendererCache = new WeakMap();
+
+  domCompat.patchConditionals((conditional) => (...args) => {
+    const signal = conditional(...args);
+    const hasAttrs = args.length > 1;
+    return (scope, renderer, clean) => {
+      return signal(scope, create5to6Renderer(renderer, hasAttrs), clean);
+    };
+  });
+
+  function create5to6Renderer(renderer, hasAttrs) {
+    let newRenderer = renderer;
+    if (renderer && typeof renderer !== "string") {
+      const rendererFromAnywhere =
+      renderer._ ||
+      renderer.render ||
+      renderer.renderer && renderer.renderer.renderer ||
+      renderer.renderer;
+
+      if (!domCompat.isRenderer(rendererFromAnywhere || renderer)) {
+        newRenderer = rendererCache.get(renderer);
+        if (!newRenderer) {
+          const { Component } = renderer;
+          if (Component) {
+            const setCustomEvents = Component.prototype.aB_;
+            Component.prototype.aB_ = function (
+            customEvents,
+            scopeId)
+            {
+              for (const customEvent of customEvents) {
+                customEvent[1] = domCompat.resolveRenderer(customEvent[1]);
+              }
+
+              setCustomEvents.call(this, customEvents, scopeId);
+            };
+          }
+          newRenderer = domCompat.createRenderer(
+            (scope) => {
+              if (!hasAttrs) {
+                renderAndMorph(scope, rendererFromAnywhere, renderer, {});
+              }
+            },
+            () => {
+              const realFragment = document.createDocumentFragment();
+              _h_(null, null, realFragment);
+              return realFragment;
+            },
+            (scope, input, clean) => {
+              if (clean) return;
+              renderAndMorph(scope, rendererFromAnywhere, renderer, input);
+            }
+          );
+          rendererCache.set(renderer, newRenderer);
+        }
+      }
+    }
+    return newRenderer;
+  }
+
+  domCompat.register("@marko/tags-compat-5-to-6", create5to6Renderer);
+
+  function renderAndMorph(scope, renderer, renderBody, input) {
+    const out = defaultCreateOut();
+    let host = domCompat.getStartNode(scope);
+    let rootNode = host.fragment;
+    if (!rootNode) {
+      const component = scope.marko5Component = _i_[scope.m5c];
+      rootNode = component._A_;
+      host = rootNode.startNode;
+      domCompat.setScopeNodes(host, rootNode.endNode);
+    }
+    const existingComponent = scope.marko5Component;
+    const componentsContext = R_(out);
+    const globalComponentsContext = componentsContext.o_;
+    let customEvents;
+    globalComponentsContext.ax_ = existingComponent;
+    out.sync();
+    if (renderer) {
+      const [rawInput] = input;
+      const normalizedInput = {};
+
+      for (const key in rawInput) {
+        let value = rawInput[key];
+        if (key.startsWith("on")) {
+          const c = key[2];
+          customEvents = customEvents || {};
+          customEvents[(c === "-" ? "" : c.toLowerCase()) + key.slice(3)] = [
+          value];
+
+        } else {
+          normalizedInput[key] = rawInput[key];
+        }
+      }
+
+      renderer(normalizedInput, out);
+    } else {
+      RenderBodyComponent({ renderBody, args: input }, out);
+    }
+
+    domCompat.queueEffect(scope, () => {
+      const targetNode = out.af_().ay_;
+      morphdom(rootNode, targetNode, host, componentsContext);
+      const componentDefs = componentsContext.ad_(
+        getRootNode(host)
+      );
+      const component = componentDefs[0].r_;
+      component._A_ = rootNode;
+      component.N_ = input[0];
+      component.U_ = customEvents;
+      scope.marko5Component = component;
+    });
+  }
+
+  function getRootNode(el) {
+    var cur = el;
+    while (cur.parentNode) cur = cur.parentNode;
+    return cur;
+  }
+
+  const RenderBodyComponentId = "renderbody-renderer";
+  const RenderBodyComponent = createRenderer(
+    function (input, out, _componentDef) {
+      dynamicTag(
+        out,
+        input.renderBody,
+        null,
+        null,
+        input.args,
+        null,
+        _componentDef,
+        "0"
+      );
+    },
+    // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+    {
+      t: RenderBodyComponentId,
+      i: true
+    },
+    {}
+  );
+
+  registerComponent(RenderBodyComponentId, () => ({
+    _: RenderBodyComponent,
+    Component: defineComponent({}, RenderBodyComponent)
+  }));
+};

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

@@ -0,0 +1,171 @@
+"use strict";const initComponentsTag = require("../../../core-tags/components/init-components-tag");
+const {
+  R_
+} = require("../../components/ComponentsContext");
+const createRenderer = require("../../components/renderer");
+const defaultCreateOut = require("../../createOut");
+const dynamicTag5 = require("../dynamic-tag");
+
+exports.p = function (tagsAPI) {
+  const {
+    patchDynamicTag,
+    createRenderFn,
+    fork,
+    write,
+    makeSerializable,
+    register,
+    writeScope,
+    nextScopeId,
+    getRegistryInfo
+  } = tagsAPI;
+  const FN_TO_JSON = function () {
+    // TODO: this should instead return an object that contains getRegistryInfo
+    // then in the dom-compat, handle that object to lookup the function in the registry
+    // (we also need to do this for events)
+    return getRegistryInfo(this);
+  };
+
+  const isMarko6 = (fn) => !!fn.bm_;
+  const isMarko5 = (fn) => !fn.bm_;
+
+  dynamicTag5.bk_ = function tagsToVdom(
+  tagsRenderer,
+  renderBody,
+  args)
+  {
+    if (tagsRenderer ? isMarko5(tagsRenderer) : isMarko5(renderBody))
+    return tagsRenderer;
+
+    if (!tagsRenderer && renderBody) {
+      renderBody.toJSON = FN_TO_JSON;
+    }
+
+    return (input, out) =>
+    TagsCompat(
+      args ?
+      { i: args, r: (args) => (tagsRenderer || renderBody)(...args) } :
+      { i: input, r: tagsRenderer || renderBody },
+      out
+    );
+  };
+
+  const TagsCompatId = "tags-compat";
+  const TagsCompat = createRenderer(
+    function (_, out, componentDef, component) {
+      const input = _.i;
+      const tagsRenderer = _.r;
+      const renderFn = createRenderFn(tagsRenderer);
+      const $global = out.global;
+      const streamData = $global.streamData = $global.streamData || {};
+
+      $global.serializedGlobals = $global.serializedGlobals || {};
+      $global.serializedGlobals.componentIdToScopeId = true;
+      $global.componentIdToScopeId = $global.componentIdToScopeId || {};
+      $global.componentIdToScopeId[component.id] = streamData.scopeId || 0;
+      out.bf(out._Y_, component, true);
+      renderFn(out.beginAsync(), input, {}, streamData);
+      out.ef();
+    },
+    // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+    {
+      t: TagsCompatId
+    },
+    {}
+  );
+
+  patchDynamicTag(
+    function getRenderer(tag) {
+      const renderer = tag._ || tag.renderBody || tag;
+      if (isMarko6(renderer)) return renderer;
+
+      const renderer5 =
+      tag._ ||
+      tag.render ||
+      tag.renderer && tag.renderer.renderer ||
+      tag.renderer;
+      const renderBody5 = tag.renderBody || tag;
+
+      return (input, ...args) => {
+        const out = defaultCreateOut();
+        let customEvents;
+
+        out.global.streamData = tagsAPI.$_streamData;
+
+        if (renderer5) {
+          const normalizedInput = {};
+
+          for (const key in input) {
+            let value = input[key];
+            if (key.startsWith("on") && typeof value === "function") {
+              const c = key[2];
+              customEvents = customEvents || [];
+              customEvents.push([
+              (c === "-" ? "" : c.toLowerCase()) + key.slice(3),
+              value]
+              );
+              value.toJSON = FN_TO_JSON;
+            } else {
+              normalizedInput[key] = input[key];
+            }
+          }
+          renderer5(normalizedInput, out);
+        } else {
+          renderBody5(out, input, ...args);
+        }
+
+        const componentsContext = R_(out);
+        const component = componentsContext.b_[0];
+        if (component) {
+          component.r_.U_ = customEvents;
+          writeScope(nextScopeId(), {
+            m5c: component.id
+          });
+        }
+
+        initComponentsTag({}, out);
+
+        let async;
+        out.once("finish", (result) => {
+          if (!async) {
+            async = false;
+            write(result.toString());
+          }
+        });
+
+        out.end();
+
+        if (async !== false) {
+          async = true;
+          fork(out, (result) => {
+            write(result.toString());
+          });
+        }
+      };
+    },
+    function createRenderer(renderFn) {
+      renderFn.bm_ = true;
+      return renderFn;
+    }
+  );
+
+  function dummyCreate5to6Renderer() {}
+
+  register(dummyCreate5to6Renderer, "@marko/tags-compat-5-to-6");
+
+  return function serialized5to6(renderer, id) {
+    const dummyRenderer = () => {};
+    register(dummyRenderer, id);
+    return makeSerializable(renderer, (s) =>
+    s.
+    value(dummyCreate5to6Renderer).
+    code("(").
+    value(dummyRenderer).
+    code(",!0)")
+    );
+  };
+};

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.bu_;
+var escapeXmlString = escapeXmlHelper.bn_;
 
 function noop() {}
 
@@ -104,7 +104,7 @@ function AsyncStream(global, writer, parentOut) {
   this._X_ = null;
   this._Y_ = null;
   this.b__ = null;
-  this.bv_ = false;
+  this.bo_ = false;
 }
 
 AsyncStream.DEFAULT_TIMEOUT = 10000;
@@ -125,11 +125,11 @@ AsyncStream.enableAsyncStackTrace = function () {
 var proto = AsyncStream.prototype = {
   constructor: AsyncStream,
   A_: typeof document === "object" && document,
-  bw_: true,
+  bp_: true,
 
   [Symbol.asyncIterator]() {
-    if (this.bx_) {
-      return this.bx_;
+    if (this.bq_) {
+      return this.bq_;
     }
 
     const originalWriter = this._state.writer;
@@ -190,7 +190,7 @@ var proto = AsyncStream.prototype = {
       };
     }
 
-    return this.bx_ = {
+    return this.bq_ = {
       next: iteratorNextFn,
       [Symbol.asyncIterator]() {
         return this;
@@ -235,7 +235,7 @@ var proto = AsyncStream.prototype = {
     return this._state.writer.toString();
   },
 
-  by_: function () {
+  br_: function () {
     this._result = this._result || new RenderResult(this);
     return this._result;
   },
@@ -286,7 +286,7 @@ var proto = AsyncStream.prototype = {
           }
 
           this._lastCount++;
-          newStream.bv_ = true;
+          newStream.bo_ = true;
         }
 
         name = options.name;
@@ -332,7 +332,7 @@ var proto = AsyncStream.prototype = {
     }
 
     if (state.events !== state.stream) {
-      state.events.emit("finish", this.by_());
+      state.events.emit("finish", this.br_());
     }
   },
 
@@ -404,7 +404,7 @@ var proto = AsyncStream.prototype = {
         parentOut._handleChildDone(this);
       }
     } else {
-      if (childOut.bv_) {
+      if (childOut.bo_) {
         this._lastCount--;
       }
 
@@ -445,7 +445,7 @@ var proto = AsyncStream.prototype = {
     var state = this._state;
 
     if (event === "finish" && state.finished === true) {
-      callback(this.by_());
+      callback(this.br_());
     } else if (event === "last") {
       this.onLast(callback);
     } else {
@@ -459,7 +459,7 @@ var proto = AsyncStream.prototype = {
     var state = this._state;
 
     if (event === "finish" && state.finished === true) {
-      callback(this.by_());
+      callback(this.br_());
     } else if (event === "last") {
       this.onLast(callback);
     } else {

package/dist/runtime/html/helpers/_dynamic-attr.js

@@ -1,7 +1,7 @@
 "use strict";
 var attrHelper = require("./attr");
-var notEmptyAttr = attrHelper.bz_;
-var isEmptyAttrValue = attrHelper.bA_;
+var notEmptyAttr = attrHelper.bs_;
+var isEmptyAttrValue = attrHelper.bt_;
 var classHelper = require("./class-attr");
 var styleHelper = require("./style-attr");
 

package/dist/runtime/html/helpers/attr.js

@@ -2,13 +2,13 @@
 
 var escapeQuoteHelpers = require("./escape-quotes");
 var escapeDoubleQuotes = escapeQuoteHelpers.m_;
-var escapeSingleQuotes = escapeQuoteHelpers.bB_;
+var escapeSingleQuotes = escapeQuoteHelpers.bu_;
 
 
 module.exports = maybeEmptyAttr;
 
-maybeEmptyAttr.bz_ = notEmptyAttr;
-maybeEmptyAttr.bA_ = isEmpty;
+maybeEmptyAttr.bs_ = notEmptyAttr;
+maybeEmptyAttr.bt_ = isEmpty;
 
 function maybeEmptyAttr(name, value) {
   if (isEmpty(value)) {

package/dist/runtime/html/helpers/data-marko.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var escapeQuoteHelpers = require("./escape-quotes");
-var escapeSingleQuotes = escapeQuoteHelpers.bB_;
+var escapeSingleQuotes = escapeQuoteHelpers.bu_;
 var escapeDoubleQuotes = escapeQuoteHelpers.m_;
 var FLAG_WILL_RERENDER_IN_BROWSER = 1;
 // var FLAG_HAS_RENDER_BODY = 2;

package/dist/runtime/html/helpers/escape-quotes.js

@@ -6,7 +6,7 @@ exports.d = function (value) {
 
 exports.m_ = escapeDoubleQuotes;
 
-exports.bB_ = escapeSingleQuotes;
+exports.bu_ = escapeSingleQuotes;
 
 function escapeSingleQuotes(value, startPos) {
   return escapeQuote(value, startPos, "'", "'");

package/dist/runtime/html/helpers/escape-xml.js

@@ -12,7 +12,7 @@ module.exports.x = function (value) {
   return escapeXML(value + "");
 };
 
-exports.bu_ = escapeXML;
+exports.bn_ = escapeXML;
 
 function escapeXML(str) {
   var len = str.length;

package/dist/runtime/renderable.js

@@ -73,7 +73,7 @@ module.exports = function (target, renderer) {
       }
 
       render(localData, out);
-      return out.by_();
+      return out.br_();
     },
 
     /**
@@ -160,7 +160,7 @@ module.exports = function (target, renderer) {
         finalData = {};
       }
 
-      if (out && out.bw_) {
+      if (out && out.bp_) {
         finalOut = out;
         shouldEnd = false;
         extend(out.global, globalData);
@@ -179,7 +179,7 @@ module.exports = function (target, renderer) {
       if (callback) {
         finalOut.
         on("finish", function () {
-          callback(null, finalOut.by_(), finalOut);
+          callback(null, finalOut.br_(), finalOut);
         }).
         once("error", callback);
       }