marko 5.37.2 → 6.0.0-3.5

package/dist/compiler/modules.js

@@ -1,5 +0,0 @@
-"use strict";
-
-if (typeof document === "undefined") {
-  exports.require = require;
-}

package/dist/core-tags/components/init-components-tag.js

@@ -1,54 +0,0 @@
-"use strict";
-
-const INIT_COMPONENTS_KEY = Symbol();
-
-const addComponentsFromContext =
-require("../../runtime/components").___addComponentsFromContext;
-const getInitComponentsCode =
-require("../../runtime/components").___getInitComponentsCode;
-
-function addComponentsFromOut(source, target) {
-  const sourceOut = source.out || source;
-  const targetOut = target || sourceOut;
-  const componentsContext = sourceOut.___components;
-  const componentDefs = targetOut.writer.get("componentDefs");
-  addComponentsFromContext(componentsContext, componentDefs);
-}
-
-function addInitScript(writer) {
-  const out = writer.state.root;
-  const componentDefs = writer.get("componentDefs");
-  writer.script(getInitComponentsCode(out, componentDefs));
-}
-
-module.exports = function render(input, out) {
-  const $global = out.global;
-  if ($global[INIT_COMPONENTS_KEY] === undefined) {
-    $global[INIT_COMPONENTS_KEY] = true;
-
-    out.on("await:finish", addComponentsFromOut);
-    out.on("___toString", addInitScript);
-
-    if (out.isSync() === true) {
-      // Generate initialization code for any of the UI components that were
-      // rendered synchronously
-      addComponentsFromOut(out);
-    } else {
-      // Generate initialization code for any of the UI components that were
-      // rendered asynchronously, but were outside an `<await>` tag
-      // (each `<await>` tag will have its own component initialization block)
-      const asyncOut = out.beginAsync({ last: true, timeout: -1 });
-      out.onLast(function (next) {
-        // Ensure we're getting init code starting from the root
-        let rootOut = out;
-        while (rootOut._parentOut) {
-          rootOut = rootOut._parentOut;
-        }
-        // Write out all of the component init code from the main out
-        addComponentsFromOut(rootOut, asyncOut);
-        asyncOut.end();
-        next();
-      });
-    }
-  }
-};

package/dist/core-tags/components/preferred-script-location-tag.js

@@ -1,25 +0,0 @@
-"use strict";
-
-function forceScriptTagAtThisPoint(out) {
-  const writer = out.writer;
-
-  out.global.___isLastFlush = true;
-  const htmlSoFar = writer.toString();
-  out.global.___isLastFlush = undefined;
-
-  writer.clear();
-  writer.write(htmlSoFar);
-}
-
-module.exports = function render(input, out) {
-  if (out.isSync() === true) {
-    forceScriptTagAtThisPoint(out);
-  } else {
-    const asyncOut = out.beginAsync({ last: true, timeout: -1 });
-    out.onLast(function (next) {
-      forceScriptTagAtThisPoint(asyncOut);
-      asyncOut.end();
-      next();
-    });
-  }
-};

package/dist/core-tags/components/preserve-tag.js

@@ -1 +0,0 @@
-"use strict";module.exports = require("@internal/preserve-tag");

package/dist/core-tags/core/__flush_here_and_after__.js

@@ -1,44 +0,0 @@
-"use strict";const BufferedWriter = require("../../runtime/html/BufferedWriter");
-
-module.exports = function __flushHereAndAfter__(input, out) {
-  if (out.isSync()) {
-    // We create an async out that we pinky promise is going to be sync in order to postpone execution of the renderBody.
-    out._sync = false;
-    const asyncOut = out.beginAsync({ last: true });
-    out._sync = true;
-    asyncOut.sync();
-    out.onLast(() => {
-      input.renderBody(asyncOut);
-      asyncOut.end();
-    });
-  } else {
-    let flushed = false;
-    const asyncOut = out.beginAsync({ last: true });
-    const nextWriter = out.writer;
-
-    out.on("___toString", (writer) => {
-      if (writer instanceof BufferedWriter) {
-        if (flushed) {
-          const detachedOut = out.createOut();
-          detachedOut.sync();
-          input.renderBody(detachedOut);
-          writer._content = detachedOut.toString() + writer._content;
-        } else if (writer.next === nextWriter) {
-          asyncOut.sync();
-          input.renderBody(asyncOut);
-          asyncOut.end();
-          flushed = true;
-        }
-      }
-    });
-
-    out.onLast(() => {
-      if (!flushed) {
-        asyncOut.sync();
-        input.renderBody(asyncOut);
-        asyncOut.end();
-        flushed = true;
-      }
-    });
-  }
-};

package/dist/core-tags/core/await/AsyncValue.js

@@ -1,121 +0,0 @@
-"use strict";var queueMicrotask = require("@internal/set-immediate").___queueMicrotask;
-
-function AsyncValue() {
-  /**
-   * The data that was provided via call to resolve(data).
-   * This property is assumed to be public and available for inspection.
-   */
-  this.___value = undefined;
-
-  /**
-   * The data that was provided via call to reject(err)
-   * This property is assumed to be public and available for inspection.
-   */
-  this.___error = undefined;
-
-  /**
-   * The queue of callbacks that are waiting for data
-   */
-  this.___callbacks = undefined;
-
-  /**
-   * The state of the data holder (STATE_INITIAL, STATE_RESOLVED, or STATE_REJECTED)
-   */
-  this.___settled = false;
-}
-
-function notifyCallbacks(asyncValue, err, value) {
-  var callbacks = asyncValue.___callbacks;
-  if (callbacks) {
-    // clear out the registered callbacks (we still have reference to the original value)
-    asyncValue.___callbacks = undefined;
-
-    // invoke all of the callbacks and use their scope
-    for (var i = 0; i < callbacks.length; i++) {
-      // each callback is actually an object with "scope and "callback" properties
-      var callback = callbacks[i];
-      callback(err, value);
-    }
-  }
-}
-
-AsyncValue.prototype = {
-  /**
-   * Adds a callback to the queue. If there is not a pending request to load data
-   * and we have a "loader" then we will use that loader to request the data.
-   * The given callback will be invoked when there is an error or resolved data
-   * available.
-   */
-  ___done: function (callback) {
-    // Do we already have data or error?
-    if (this.___settled) {
-      // invoke the callback immediately
-      return callback(this.___error, this.___value);
-    }
-
-    var callbacks = this.___callbacks || (this.___callbacks = []);
-    callbacks.push(callback);
-  },
-
-  /**
-   * This method will trigger any callbacks to be notified of rejection (error).
-   * If this data holder has a loader then the data holder will be returned to
-   * its initial state so that any future requests to load data will trigger a
-   * new load call.
-   */
-  ___reject: function (err) {
-    if (this.___settled) {
-      return;
-    }
-
-    // remember the error
-    this.___error = err;
-
-    // Go to the rejected state if we don't have a loader.
-    // If we do have a loader then return to the initial state
-    // (we do this so that next call to done() will trigger load
-    // again in case the error was transient).
-    this.___settled = true;
-
-    // always notify callbacks regardless of whether or not we return to the initial state
-    notifyCallbacks(this, err, null);
-  },
-
-  /**
-   * This method will trigger any callbacks to be notified of data.
-   */
-  ___resolve: function (value) {
-    if (this.___settled) {
-      return;
-    }
-
-    if (value && typeof value.then === "function") {
-      // eslint-disable-next-line @typescript-eslint/no-this-alias
-      var asyncValue = this;
-
-      var finalPromise = value.then(
-        function onFulfilled(value) {
-          queueMicrotask(asyncValue.___resolve.bind(asyncValue, value));
-        },
-        function onRejected(err) {
-          queueMicrotask(asyncValue.___reject.bind(asyncValue, err));
-        }
-      );
-
-      if (finalPromise.done) {
-        finalPromise.done();
-      }
-    } else {
-      // remember the state
-      this.___value = value;
-
-      // go to the resolved state
-      this.___settled = true;
-
-      // notify callbacks
-      notifyCallbacks(this, null, value);
-    }
-  }
-};
-
-module.exports = AsyncValue;

package/dist/core-tags/core/await/client-reorder-runtime.js

@@ -1,51 +0,0 @@
-"use strict";function $af(
-id,
-after,
-doc,
-sourceEl,
-targetEl,
-docFragment,
-childNodes,
-i,
-len,
-af)
-{
-  af = $af;
-
-  if (after && !af[after]) {
-    (af[after = after + "$"] || (af[after] = [])).push(id);
-  } else {
-    doc = document;
-    sourceEl = doc.getElementById("af" + id);
-    targetEl = doc.getElementById("afph" + id);
-    docFragment = doc.createDocumentFragment();
-    childNodes = sourceEl.childNodes;
-    i = 0;
-    len = childNodes.length;
-
-    for (; i < len; i++) {
-      docFragment.appendChild(childNodes.item(0));
-    }
-
-    if (targetEl) {
-      targetEl.parentNode.replaceChild(docFragment, targetEl);
-    }
-
-    af[id] = 1;
-
-    after = af[id + "$"];
-
-    if (after) {
-      i = 0;
-      len = after.length;
-
-      for (; i < len; i++) {
-        af(after[i]);
-      }
-    }
-  }
-
-  // sourceEl.parentNode.removeChild(sourceEl);
-}
-
-window.$af = $af;

package/dist/core-tags/core/await/index.d.marko

@@ -1,10 +0,0 @@
-export interface Input<T> {
-  value: readonly [T];
-  then?: Marko.AttrTag<{ renderBody: Marko.Body<[Awaited<T>]> }>;
-  catch?: Marko.AttrTag<{ renderBody: Marko.Body<[unknown]> }>;
-  placeholder?: Marko.AttrTag<{ renderBody: Marko.Body }>;
-  "client-reorder"?: boolean;
-  name?: string;
-  timeout?: number;
-  "show-after"?: string;
-}

package/dist/core-tags/core/await/renderer.js

@@ -1,249 +0,0 @@
-"use strict";
-// eslint-disable-next-line no-constant-binary-expression
-var complain = "MARKO_DEBUG" && require("complain");
-var AsyncValue = require("./AsyncValue");
-
-function safeRenderBody(renderBody, targetOut, data) {
-  try {
-    renderBody(targetOut, data);
-  } catch (err) {
-    return err;
-  }
-}
-
-function requestData(provider, timeout) {
-  var asyncValue = new AsyncValue();
-
-  if (typeof provider === "function") {
-    // eslint-disable-next-line no-constant-condition
-    if ("MARKO_DEBUG") {
-      complain(
-        "Passing a callback function to the <await> tag has been deprecated, please use a promise instead.",
-        { level: 1, locationIndex: 3 }
-      );
-    }
-
-    var callback = function (err, data) {
-      if (err) {
-        asyncValue.___reject(err);
-      } else {
-        asyncValue.___resolve(data);
-      }
-    };
-
-    var value =
-    provider.length === 1 ?
-    // one argument so only provide callback to function call
-    provider(callback) :
-    // two arguments so provide args and callback to function call
-    provider(null, callback);
-
-    if (value !== undefined) {
-      asyncValue.___resolve(value);
-    }
-  } else {
-    // Assume the provider is a data object...
-    asyncValue.___resolve(provider);
-  }
-
-  if (timeout == null) {
-    timeout = 10000;
-  }
-
-  var error;
-  var errorMsg = "Timed out after " + timeout + "ms";
-  // eslint-disable-next-line no-constant-condition
-  if ("MARKO_DEBUG") {
-    // Make sure we have a meaningful stack trace in development preparing the stacktrace upfront.
-    // If we create it inside the setTimeout, we will end up with a short, not meaningful, stack trace
-    // We only do it in development to avoid overhead in production
-    error = new Error(errorMsg);
-  }
-  if (timeout > 0) {
-    let timeoutId = setTimeout(function () {
-      timeoutId = null;
-      if (!error) error = new Error(errorMsg);
-      error.code = "ERR_AWAIT_TIMEDOUT";
-      error.name = "TimeoutError";
-      asyncValue.___reject(error);
-    }, timeout);
-
-    asyncValue.___done(function () {
-      if (timeoutId != null) {
-        clearTimeout(timeoutId);
-      }
-    });
-  }
-
-  return asyncValue;
-}
-
-const LAST_OPTIONS = { last: true, name: "await:finish" };
-
-module.exports = function awaitTag(input, out) {
-  var clientReorder =
-  typeof document === "undefined" &&
-  input.clientReorder === true &&
-  !out.isVDOM;
-
-  var name = input.name || input._name;
-  var timeout = input.timeout;
-  var provider = input._provider;
-  var asyncValue = requestData(provider, timeout);
-  var placeholderRenderer = input.placeholder && input.placeholder.renderBody;
-
-  if (asyncValue.___settled) {
-    renderContents(asyncValue.___error, asyncValue.___value, input, out);
-    return;
-  }
-
-  var asyncOut;
-  var clientReorderContext;
-
-  var awaitInfo = {
-    name: name,
-    clientReorder: clientReorder,
-    dataProvider: provider
-  };
-
-  if (clientReorder) {
-    awaitInfo.parent = out;
-    awaitInfo.after = input.showAfter;
-
-    clientReorderContext =
-    out.global.___clientReorderContext || (
-    out.global.___clientReorderContext = {
-      instances: [],
-      nextId: 0
-    });
-
-    /** SHOULD MATCH THE reorder-renderer.js IMPLEMENTATION */
-    var reorderFunctionId =
-    out.global.runtimeId !== "M" ? "af" + out.global.runtimeId : "af";
-
-    var id = awaitInfo.id =
-    input.name ||
-    (out.global.componentIdPrefix || 0) + clientReorderContext.nextId++;
-    var placeholderIdAttrValue = reorderFunctionId + "ph" + id;
-
-    if (placeholderRenderer) {
-      out.write('<span id="' + placeholderIdAttrValue + '">');
-      placeholderRenderer(out);
-      out.write("</span>");
-    } else {
-      out.write('<noscript id="' + placeholderIdAttrValue + '"></noscript>');
-    }
-
-    // If `client-reorder` is enabled then we asynchronously render the await instance to a new
-    // "out" instance so that we can Write to a temporary in-memory buffer.
-    asyncOut = awaitInfo.out = out.createOut();
-
-    var oldEmit = asyncOut.emit;
-
-    // Since we are rendering the await instance to a new and separate out,
-    // we want to proxy any child events to the main AsyncWriter in case anyone is interested
-    // in those events. This is also needed for the following events to be handled correctly:
-    //
-    // - await:begin
-    // - await:beforeRender
-    // - await:finish
-    //
-    asyncOut.emit = function (event) {
-      if (event !== "finish" && event !== "error") {
-        // We don't want to proxy the finish and error events since those are
-        // very specific to the AsyncWriter associated with the await instance
-        out.emit.apply(out, arguments);
-      }
-
-      oldEmit.apply(asyncOut, arguments);
-    };
-
-    if (clientReorderContext.instances) {
-      clientReorderContext.instances.push(awaitInfo);
-    }
-
-    out.emit("await:clientReorder", awaitInfo);
-  } else {
-    out.flush(); // Flush everything up to this await instance
-    asyncOut = awaitInfo.out = out.beginAsync({
-      timeout: 0, // We will use our code for controlling timeout
-      name: name
-    });
-  }
-
-  var beforeRenderEmitted = false;
-
-  out.emit("await:begin", awaitInfo);
-
-  function renderBody(err, data) {
-    if (awaitInfo.finished) {
-      return;
-    }
-
-    if (err) {
-      awaitInfo.error = err;
-    }
-
-    if (!beforeRenderEmitted) {
-      beforeRenderEmitted = true;
-      out.emit("await:beforeRender", awaitInfo);
-    }
-
-    renderContents(err, data, input, asyncOut);
-
-    awaitInfo.finished = true;
-
-    if (clientReorder) {
-      asyncOut.end();
-      out.flush();
-    } else {
-      // When using client reordering we want to delay
-      // this event until after the code to move
-      // the async fragment into place has been written
-      let asyncLastOut = asyncOut.beginAsync(LAST_OPTIONS);
-      asyncOut.onLast(function () {
-        var oldWriter = asyncOut.writer;
-        // We swap out the writer so that writing will happen to our `asyncLastOut`
-        // even though we are still passing along the original `asyncOut`. We have
-        // to pass along the original `asyncOut` because that has contextual
-        // information (such as the rendered UI components)
-        asyncOut.writer = asyncLastOut.writer;
-        out.emit("await:finish", awaitInfo);
-        asyncOut.writer = oldWriter;
-        asyncLastOut.end();
-        out.flush();
-      });
-
-      asyncOut.end();
-    }
-  }
-
-  asyncValue.___done(renderBody);
-};
-
-function renderContents(err, data, input, out) {
-  var resultRenderer = input.then && input.then.renderBody;
-  var errorRenderer = input.catch && input.catch.renderBody;
-
-  if (err) {
-    if (input.catch) {
-      if (errorRenderer) {
-        try {
-          errorRenderer(out, err);
-        } catch (err2) {
-          out.error(err2);
-        }
-      }
-    } else {
-      out.error(err);
-    }
-  } else {
-    if (resultRenderer) {
-      var renderBodyErr = safeRenderBody(resultRenderer, out, data);
-
-      if (renderBodyErr) {
-        return renderContents(renderBodyErr, data, input, out);
-      }
-    }
-  }
-}