astro 2.9.1 → 2.9.3

package/dist/runtime/server/render/slot.js

@@ -1,5 +1,6 @@
 import { HTMLString, markHTMLString } from "../escape.js";
 import { renderChild } from "./any.js";
+import { chunkToString } from "./common.js";
 const slotString = Symbol.for("astro:slot-string");
 class SlotString extends HTMLString {
   constructor(content, instructions) {
@@ -12,29 +13,35 @@ slotString;
 function isSlotString(str) {
   return !!str[slotString];
 }
-async function* renderSlot(result, slotted, fallback) {
-  if (slotted) {
-    let iterator = renderChild(typeof slotted === "function" ? slotted(result) : slotted);
-    yield* iterator;
-  }
-  if (fallback && !slotted) {
-    yield* renderSlot(result, fallback);
+function renderSlot(result, slotted, fallback) {
+  if (!slotted && fallback) {
+    return renderSlot(result, fallback);
   }
+  return {
+    async render(destination) {
+      await renderChild(destination, typeof slotted === "function" ? slotted(result) : slotted);
+    }
+  };
 }
 async function renderSlotToString(result, slotted, fallback) {
   let content = "";
   let instructions = null;
-  let iterator = renderSlot(result, slotted, fallback);
-  for await (const chunk of iterator) {
-    if (typeof chunk.type === "string") {
-      if (instructions === null) {
-        instructions = [];
+  const temporaryDestination = {
+    write(chunk) {
+      if (chunk instanceof Response)
+        return;
+      if (typeof chunk === "object" && "type" in chunk && typeof chunk.type === "string") {
+        if (instructions === null) {
+          instructions = [];
+        }
+        instructions.push(chunk);
+      } else {
+        content += chunkToString(result, chunk);
       }
-      instructions.push(chunk);
-    } else {
-      content += chunk;
     }
-  }
+  };
+  const renderInstance = renderSlot(result, slotted, fallback);
+  await renderInstance.render(temporaryDestination);
   return markHTMLString(new SlotString(content, instructions));
 }
 async function renderSlots(result, slots = {}) {

package/dist/runtime/server/render/util.d.ts

@@ -6,21 +6,3 @@ export declare function formatList(values: string[]): string;
 export declare function addAttribute(value: any, key: string, shouldEscape?: boolean): any;
 export declare function internalSpreadAttributes(values: Record<any, any>, shouldEscape?: boolean): any;
 export declare function renderElement(name: string, { props: _props, children }: SSRElement, shouldEscape?: boolean): string;
-/**
- * This will take an array of async iterables and start buffering them eagerly.
- * To avoid useless buffering, it will only start buffering the next tick, so the
- * first sync iterables won't be buffered.
- */
-export declare function bufferIterators<T>(iterators: AsyncIterable<T>[]): AsyncIterable<T>[];
-export declare class EagerAsyncIterableIterator {
-    #private;
-    constructor(iterable: AsyncIterable<any>);
-    /**
-     * Starts to eagerly fetch the inner iterator and cache the results.
-     * Note: This might not be called after next() has been called once, e.g. the iterator is started
-     */
-    buffer(): Promise<void>;
-    next(): Promise<IteratorResult<any, any>>;
-    isStarted(): boolean;
-    [Symbol.asyncIterator](): this;
-}

package/dist/runtime/server/render/util.js

@@ -103,109 +103,8 @@ function renderElement(name, { props: _props, children = "" }, shouldEscape = tr
   }
   return `<${name}${internalSpreadAttributes(props, shouldEscape)}>${children}</${name}>`;
 }
-const iteratorQueue = [];
-function queueIteratorBuffers(iterators) {
-  if (iteratorQueue.length === 0) {
-    setTimeout(() => {
-      iteratorQueue.forEach((its) => its.forEach((it) => !it.isStarted() && it.buffer()));
-      iteratorQueue.length = 0;
-    });
-  }
-  iteratorQueue.push(iterators);
-}
-function bufferIterators(iterators) {
-  const eagerIterators = iterators.map((it) => new EagerAsyncIterableIterator(it));
-  queueIteratorBuffers(eagerIterators);
-  return eagerIterators;
-}
-class EagerAsyncIterableIterator {
-  #iterable;
-  #queue = new Queue();
-  #error = void 0;
-  #next;
-  /**
-   * Whether the proxy is running in buffering or pass-through mode
-   */
-  #isBuffering = false;
-  #gen = void 0;
-  #isStarted = false;
-  constructor(iterable) {
-    this.#iterable = iterable;
-  }
-  /**
-   * Starts to eagerly fetch the inner iterator and cache the results.
-   * Note: This might not be called after next() has been called once, e.g. the iterator is started
-   */
-  async buffer() {
-    if (this.#gen) {
-      throw new Error("Cannot not switch from non-buffer to buffer mode");
-    }
-    this.#isBuffering = true;
-    this.#isStarted = true;
-    this.#gen = this.#iterable[Symbol.asyncIterator]();
-    let value = void 0;
-    do {
-      this.#next = this.#gen.next();
-      try {
-        value = await this.#next;
-        this.#queue.push(value);
-      } catch (e) {
-        this.#error = e;
-      }
-    } while (value && !value.done);
-  }
-  async next() {
-    if (this.#error) {
-      throw this.#error;
-    }
-    if (!this.#isBuffering) {
-      if (!this.#gen) {
-        this.#isStarted = true;
-        this.#gen = this.#iterable[Symbol.asyncIterator]();
-      }
-      return await this.#gen.next();
-    }
-    if (!this.#queue.isEmpty()) {
-      return this.#queue.shift();
-    }
-    await this.#next;
-    return this.#queue.shift();
-  }
-  isStarted() {
-    return this.#isStarted;
-  }
-  [Symbol.asyncIterator]() {
-    return this;
-  }
-}
-class Queue {
-  constructor() {
-    this.head = void 0;
-    this.tail = void 0;
-  }
-  push(item) {
-    if (this.head === void 0) {
-      this.head = { item };
-      this.tail = this.head;
-    } else {
-      this.tail.next = { item };
-      this.tail = this.tail.next;
-    }
-  }
-  isEmpty() {
-    return this.head === void 0;
-  }
-  shift() {
-    var _a, _b;
-    const val = (_a = this.head) == null ? void 0 : _a.item;
-    this.head = (_b = this.head) == null ? void 0 : _b.next;
-    return val;
-  }
-}
 export {
-  EagerAsyncIterableIterator,
   addAttribute,
-  bufferIterators,
   defineScriptVars,
   formatList,
   internalSpreadAttributes,

package/dist/vite-plugin-astro/compile.js

@@ -17,7 +17,6 @@ async function cachedFullCompilation({
       tsconfigRaw: {
         compilerOptions: {
           // Ensure client:only imports are treeshaken
-          // @ts-expect-error anticipate esbuild 0.18 feature
           verbatimModuleSyntax: false,
           importsNotUsedAsValues: "remove"
         }

package/dist/vite-plugin-jsx/index.js

@@ -121,7 +121,6 @@ function jsx({ settings, logging }) {
           tsconfigRaw: {
             compilerOptions: {
               // Ensure client:only imports are treeshaken
-              // @ts-expect-error anticipate esbuild 0.18 feature
               verbatimModuleSyntax: false,
               importsNotUsedAsValues: "remove"
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -155,7 +155,7 @@
     "typescript": "*",
     "unist-util-visit": "^4.1.2",
     "vfile": "^5.3.7",
-    "vite": "^4.3.9",
+    "vite": "^4.4.6",
     "vitefu": "^0.2.4",
     "which-pm": "^2.0.0",
     "yargs-parser": "^21.1.1",