marko 6.0.0-next.3.69 → 6.0.0-next.3.70

package/dist/debug/html.mjs

@@ -2067,7 +2067,7 @@ function tryCatch(content, catchContent) {
       catchChunk.render(catchContent, catchBoundary.signal.reason);
       state.reorder(catchChunk);
       boundary.endAsync();
-    } else if (catchBoundary.done) {
+    } else if (!catchBoundary.count) {
       boundary.endAsync();
     } else {
       boundary.onNext();
@@ -2092,6 +2092,7 @@ var State2 = class {
   hasReorderRuntime = false;
   hasWrittenResume = false;
   trailerHTML = "";
+  resumes = "";
   nonceAttr = "";
   serializer = new Serializer();
   writeReorders = null;
@@ -2155,7 +2156,8 @@ var Boundary = class extends AbortController {
   onNext = NOOP;
   count = 0;
   get done() {
-    return this.count === 0;
+    flushSerializer(this);
+    return !this.count;
   }
   startAsync() {
     if (!this.signal.aborted) {
@@ -2261,145 +2263,152 @@ var Chunk = class {
       $chunk = prev;
     }
   }
-};
-function prepareChunk(chunk) {
-  const head = chunk.consume();
-  const { boundary, effects } = head;
-  const { state } = boundary;
-  const { $global: $global2, runtimePrefix, serializer, nonceAttr } = state;
-  let { html, scripts } = head;
-  let hasWalk = false;
-  head.effects = "";
-  if (state.needsMainRuntime && !state.hasMainRuntime) {
-    state.hasMainRuntime = true;
-    scripts = concatScripts(
-      scripts,
-      WALKER_RUNTIME_CODE + '("' + $global2.runtimeId + '")("' + $global2.renderId + '")'
-    );
-  }
-  let resumes = "";
-  if (state.writeScopes || serializer.flushed) {
-    let { lastSerializedScopeId } = state;
-    const serializeData = [];
-    if (!state.hasGlobals) {
-      state.hasGlobals = true;
-      serializeData.push(getFilteredGlobals(state.$global));
-    }
-    for (const key in state.writeScopes) {
-      const scope = state.writeScopes[key];
-      const scopeId = getScopeId(scope);
-      const scopeIdDelta = scopeId - lastSerializedScopeId;
-      lastSerializedScopeId = scopeId + 1;
-      if (scopeIdDelta) serializeData.push(scopeIdDelta);
-      serializeData.push(scope);
-    }
-    resumes = state.serializer.stringify(serializeData, boundary);
-    state.writeScopes = null;
-    state.lastSerializedScopeId = lastSerializedScopeId;
-  }
-  if (effects) {
-    hasWalk = true;
-    resumes = resumes ? resumes + "," + effects : effects;
-  }
-  if (resumes) {
-    if (state.hasWrittenResume) {
+  flushScript() {
+    flushSerializer(this.boundary);
+    const { boundary, effects } = this;
+    const { state } = boundary;
+    const { $global: $global2, runtimePrefix, nonceAttr } = state;
+    let { resumes } = state;
+    let { html, scripts } = this;
+    let hasWalk = false;
+    if (state.needsMainRuntime && !state.hasMainRuntime) {
+      state.hasMainRuntime = true;
       scripts = concatScripts(
         scripts,
-        runtimePrefix + ".r.push(" + resumes + ")"
-      );
-    } else {
-      state.hasWrittenResume = true;
-      scripts = concatScripts(
-        scripts,
-        runtimePrefix + ".r=[" + resumes + "]"
+        WALKER_RUNTIME_CODE + '("' + $global2.runtimeId + '")("' + $global2.renderId + '")'
       );
     }
-  }
-  if (state.writeReorders) {
-    hasWalk = true;
-    if (!state.hasReorderRuntime) {
-      state.hasReorderRuntime = true;
-      html += "<style " + state.commentPrefix + nonceAttr + ">t{display:none}</style>";
-      scripts = concatScripts(
-        scripts,
-        REORDER_RUNTIME_CODE + "(" + runtimePrefix + ")"
-      );
+    if (effects) {
+      hasWalk = true;
+      resumes = resumes ? resumes + "," + effects : effects;
     }
-    for (const reorderedChunk of state.writeReorders) {
-      const { reorderId } = reorderedChunk;
-      let reorderHTML = "";
-      let reorderEffects = "";
-      let reorderScripts = "";
-      let cur = reorderedChunk;
-      reorderedChunk.reorderId = null;
-      for (; ; ) {
-        cur.flushPlaceholder();
-        const { next } = cur;
-        cur.consumed = true;
-        reorderHTML += cur.html;
-        reorderEffects = concatEffects(reorderEffects, cur.effects);
-        reorderScripts = concatScripts(reorderScripts, cur.scripts);
-        if (cur.async) {
-          reorderHTML += state.mark(
-            "#" /* ReorderMarker */,
-            cur.reorderId = state.nextReorderId()
-          );
-          cur.html = cur.effects = cur.scripts = "";
-          cur.next = null;
-        }
-        if (next) {
-          cur = next;
-        } else {
-          break;
-        }
+    if (resumes) {
+      if (state.hasWrittenResume) {
+        scripts = concatScripts(
+          scripts,
+          runtimePrefix + ".r.push(" + resumes + ")"
+        );
+      } else {
+        state.hasWrittenResume = true;
+        scripts = concatScripts(
+          scripts,
+          runtimePrefix + ".r=[" + resumes + "]"
+        );
       }
-      if (reorderEffects) {
-        if (!state.hasWrittenResume) {
-          state.hasWrittenResume = true;
-          scripts = concatScripts(
-            scripts,
-            runtimePrefix + ".r=[]"
+    }
+    if (state.writeReorders) {
+      hasWalk = true;
+      if (!state.hasReorderRuntime) {
+        state.hasReorderRuntime = true;
+        html += "<style " + state.commentPrefix + nonceAttr + ">t{display:none}</style>";
+        scripts = concatScripts(
+          scripts,
+          REORDER_RUNTIME_CODE + "(" + runtimePrefix + ")"
+        );
+      }
+      for (const reorderedChunk of state.writeReorders) {
+        const { reorderId } = reorderedChunk;
+        let reorderHTML = "";
+        let reorderEffects = "";
+        let reorderScripts = "";
+        let cur = reorderedChunk;
+        reorderedChunk.reorderId = null;
+        for (; ; ) {
+          cur.flushPlaceholder();
+          const { next } = cur;
+          cur.consumed = true;
+          reorderHTML += cur.html;
+          reorderEffects = concatEffects(reorderEffects, cur.effects);
+          reorderScripts = concatScripts(reorderScripts, cur.scripts);
+          if (cur.async) {
+            reorderHTML += state.mark(
+              "#" /* ReorderMarker */,
+              cur.reorderId = state.nextReorderId()
+            );
+            cur.html = cur.effects = cur.scripts = "";
+            cur.next = null;
+          }
+          if (next) {
+            cur = next;
+          } else {
+            break;
+          }
+        }
+        if (reorderEffects) {
+          if (!state.hasWrittenResume) {
+            state.hasWrittenResume = true;
+            scripts = concatScripts(
+              scripts,
+              runtimePrefix + ".r=[]"
+            );
+          }
+          reorderScripts = concatScripts(
+            reorderScripts,
+            "_.push(" + reorderEffects + ")"
           );
         }
-        reorderScripts = concatScripts(
-          reorderScripts,
-          "_.push(" + reorderEffects + ")"
+        scripts = concatScripts(
+          scripts,
+          reorderScripts && runtimePrefix + ".j." + reorderId + "=_=>{" + reorderScripts + "}"
         );
+        html += "<t " + state.commentPrefix + "=" + reorderId + ">" + reorderHTML + "</t>";
       }
-      scripts = concatScripts(
-        scripts,
-        reorderScripts && runtimePrefix + ".j." + reorderId + "=_=>{" + reorderScripts + "}"
-      );
-      html += "<t " + state.commentPrefix + "=" + reorderId + ">" + reorderHTML + "</t>";
+      state.writeReorders = null;
     }
-    state.writeReorders = null;
+    if (hasWalk) {
+      scripts = concatScripts(scripts, runtimePrefix + ".w()");
+    }
+    this.effects = state.resumes = "";
+    this.html = html;
+    this.scripts = scripts;
+    return this;
   }
-  if (hasWalk) {
-    scripts = concatScripts(scripts, runtimePrefix + ".w()");
+  flushHTML() {
+    this.flushScript();
+    const { boundary, scripts } = this;
+    const { state } = boundary;
+    const { $global: $global2, nonceAttr } = state;
+    const { __flush__ } = $global2;
+    let { html } = this;
+    this.html = this.scripts = "";
+    if (scripts) {
+      html += "<script" + nonceAttr + ">" + scripts + "</script>";
+    }
+    if (__flush__) {
+      $global2.__flush__ = void 0;
+      html = __flush__($global2, html);
+    }
+    if (!boundary.count) {
+      html += state.trailerHTML;
+    }
+    return html;
   }
-  head.html = html;
-  head.scripts = scripts;
-  return head;
-}
-function flushChunk(head, last) {
-  const { boundary } = head;
+};
+function flushSerializer(boundary) {
   const { state } = boundary;
-  const { html, scripts } = head;
-  const { $global: $global2 } = state;
-  const { __flush__ } = $global2;
-  let result = html;
-  head.html = head.scripts = "";
-  if (scripts) {
-    result += "<script" + state.nonceAttr + ">" + scripts + "</script>";
-  }
-  if (__flush__) {
-    $global2.__flush__ = void 0;
-    result = __flush__($global2, result);
-  }
-  if (last && state.trailerHTML) {
-    result += state.trailerHTML;
+  const { writeScopes, serializer } = state;
+  if (writeScopes || serializer.flushed) {
+    const serializeData = [];
+    let { lastSerializedScopeId } = state;
+    if (!state.hasGlobals) {
+      state.hasGlobals = true;
+      serializeData.push(getFilteredGlobals(state.$global));
+    }
+    for (const key in writeScopes) {
+      const scope = writeScopes[key];
+      const scopeId = getScopeId(scope);
+      const scopeIdDelta = scopeId - lastSerializedScopeId;
+      lastSerializedScopeId = scopeId + 1;
+      if (scopeIdDelta) serializeData.push(scopeIdDelta);
+      serializeData.push(scope);
+    }
+    state.resumes = concatEffects(
+      state.resumes,
+      serializer.stringify(serializeData, boundary)
+    );
+    state.lastSerializedScopeId = lastSerializedScopeId;
+    state.writeScopes = null;
   }
-  return result;
 }
 function writeTrailers(html) {
   $chunk.boundary.state.trailerHTML += html;
@@ -2879,7 +2888,7 @@ var compat = {
       $global2[K_TAGS_API_STATE] = state = new State2($global2);
     }
     const boundary = new Boundary(state);
-    let head = new Chunk(
+    const head = new Chunk(
       boundary,
       null,
       null
@@ -2900,24 +2909,18 @@ var compat = {
       renderer(normalizedInput);
     });
     const asyncOut = classAPIOut.beginAsync();
-    (boundary.onNext = () => {
-      if (boundary.done) {
+    queueMicrotask(
+      boundary.onNext = () => {
         if (boundary.signal.aborted) {
           asyncOut.error(boundary.signal.reason);
-        } else {
-          queueMicrotask(() => {
-            head = prepareChunk(head);
-            if (boundary.done) {
-              const { scripts, html } = head;
-              asyncOut.script(scripts);
-              asyncOut.write(html);
-              asyncOut.end();
-              head.html = head.scripts = "";
-            }
-          });
+        } else if (boundary.done) {
+          const { scripts, html } = head.consume().flushScript();
+          asyncOut.script(scripts);
+          asyncOut.write(html);
+          asyncOut.end();
         }
       }
-    })();
+    );
   },
   registerRenderer(renderer, id) {
     return register(
@@ -2978,10 +2981,7 @@ function render(input = {}) {
       ...$global2
     };
   } else {
-    $global2 = {
-      runtimeId: DEFAULT_RUNTIME_ID,
-      renderId: DEFAULT_RENDER_ID
-    };
+    $global2 = { runtimeId: DEFAULT_RUNTIME_ID, renderId: DEFAULT_RENDER_ID };
   }
   const head = new Chunk(
     new Boundary(new State2($global2), $global2.signal),
@@ -3045,19 +3045,13 @@ var ServerRenderResult = class {
         if (!(done || aborted)) {
           boundary?.abort(error);
         }
-        return Promise.resolve({
-          value: "",
-          done: true
-        });
+        return Promise.resolve({ value: "", done: true });
       },
       return(value2) {
         if (!(done || aborted)) {
           boundary?.abort(new Error("Iterator returned before consumed."));
         }
-        return Promise.resolve({
-          value: value2,
-          done: true
-        });
+        return Promise.resolve({ value: value2, done: true });
       }
     };
     function exec(_resolve, _reject) {
@@ -3112,7 +3106,7 @@ var ServerRenderResult = class {
   }
   #promise() {
     return this.#cachedPromise ||= new Promise((resolve, reject) => {
-      let head = this.#head;
+      const head = this.#head;
       this.#head = null;
       if (!head) {
         return reject(new Error("Cannot read from a consumed render result"));
@@ -3123,10 +3117,7 @@ var ServerRenderResult = class {
           boundary.onNext = NOOP2;
           reject(boundary.signal.reason);
         } else if (boundary.done) {
-          head = prepareChunk(head);
-          if (boundary.done) {
-            resolve(flushChunk(head, true));
-          }
+          resolve(head.consume().flushHTML());
         }
       })();
     });
@@ -3146,13 +3137,11 @@ var ServerRenderResult = class {
         boundary.onNext = NOOP2;
         onAbort(boundary.signal.reason);
       } else {
-        if (write2 || boundary.done) {
-          head = prepareChunk(head);
-        }
-        if (write2 || boundary.done) {
-          const html = flushChunk(head, boundary.done);
+        const { done } = boundary;
+        if (done || write2) {
+          const html = (head = head.consume()).flushHTML();
           if (html) onWrite(html);
-          if (boundary.done) {
+          if (done) {
             if (!tick2) offTick(onNext);
             onClose();
           } else {
@@ -3169,10 +3158,10 @@ var ServerRenderResult = class {
   }
   toString() {
     const head = this.#head;
-    if (!head) throw new Error("Cannot read from a consumed render result");
-    if (head.next) throw new Error("Cannot fork in sync mode");
     this.#head = null;
-    return flushChunk(prepareChunk(head), true);
+    if (!head) throw new Error("Cannot read from a consumed render result");
+    if (!head.boundary.done) throw new Error("Cannot fork in sync mode");
+    return head.consume().flushHTML();
   }
 };
 function NOOP2() {

package/dist/html/writer.d.ts

@@ -71,6 +71,7 @@ export declare class State {
     hasReorderRuntime: boolean;
     hasWrittenResume: boolean;
     trailerHTML: string;
+    resumes: string;
     nonceAttr: string;
     serializer: Serializer;
     writeReorders: Chunk[] | null;
@@ -89,7 +90,7 @@ export declare class State {
 export declare class Boundary extends AbortController {
     state: State;
     onNext: () => void;
-    private count;
+    count: number;
     constructor(state: State, parent?: AbortSignal);
     get done(): boolean;
     startAsync(): void;
@@ -116,9 +117,9 @@ export declare class Chunk {
     consume(): Chunk;
     render(content: () => void): Chunk;
     render<T>(content: (val: T) => void, val: T): Chunk;
+    flushScript(): this;
+    flushHTML(): string;
 }
-export declare function prepareChunk(chunk: Chunk): Chunk;
-export declare function flushChunk(head: Chunk, last: boolean): string;
 export declare function writeTrailers(html: string): void;
 type QueueCallback = (ticked: true) => void;
 export declare function queueTick(cb: QueueCallback): void;