astro 7.0.0-alpha.2 → 7.0.0-beta.4

package/dist/runtime/server/render/queue/renderer.js

@@ -1,103 +0,0 @@
-import { markHTMLString, escapeHTML } from "../../escape.js";
-import { chunkToString } from "../common.js";
-async function renderQueue(queue, destination) {
-  const result = queue.result;
-  const pool = queue.pool;
-  const cache = queue.htmlStringCache;
-  let batchBuffer = "";
-  let i = 0;
-  while (i < queue.nodes.length) {
-    const node = queue.nodes[i];
-    try {
-      if (canBatch(node)) {
-        const batchStart = i;
-        while (i < queue.nodes.length && canBatch(queue.nodes[i])) {
-          batchBuffer += renderNodeToString(queue.nodes[i]);
-          i = i + 1;
-        }
-        if (batchBuffer) {
-          const htmlString = cache ? cache.getOrCreate(batchBuffer) : markHTMLString(batchBuffer);
-          destination.write(htmlString);
-          batchBuffer = "";
-        }
-        if (pool) {
-          for (let j = batchStart; j < i; j++) {
-            pool.release(queue.nodes[j]);
-          }
-        }
-      } else {
-        await renderNode(node, destination, result);
-        if (pool) {
-          pool.release(node);
-        }
-        i = i + 1;
-      }
-    } catch (error) {
-      throw error;
-    }
-  }
-  if (batchBuffer) {
-    const htmlString = cache ? cache.getOrCreate(batchBuffer) : markHTMLString(batchBuffer);
-    destination.write(htmlString);
-  }
-}
-function canBatch(node) {
-  return node.type === "text" || node.type === "html-string";
-}
-function renderNodeToString(node) {
-  switch (node.type) {
-    case "text":
-      return node.content ? escapeHTML(node.content) : "";
-    case "html-string":
-      return node.html || "";
-    case "component":
-    case "instruction": {
-      return "";
-    }
-  }
-}
-async function renderNode(node, destination, result) {
-  const cache = result._experimentalQueuedRendering?.htmlStringCache;
-  switch (node.type) {
-    case "text": {
-      if (node.content) {
-        const escaped = escapeHTML(node.content);
-        const htmlString = cache ? cache.getOrCreate(escaped) : markHTMLString(escaped);
-        destination.write(htmlString);
-      }
-      break;
-    }
-    case "html-string": {
-      if (node.html) {
-        const htmlString = cache ? cache.getOrCreate(node.html) : markHTMLString(node.html);
-        destination.write(htmlString);
-      }
-      break;
-    }
-    case "instruction": {
-      if (node.instruction) {
-        destination.write(node.instruction);
-      }
-      break;
-    }
-    case "component": {
-      if (node.instance) {
-        let componentHtml = "";
-        const componentDestination = {
-          write(chunk) {
-            if (chunk instanceof Response) return;
-            componentHtml += chunkToString(result, chunk);
-          }
-        };
-        await node.instance.render(componentDestination);
-        if (componentHtml) {
-          destination.write(componentHtml);
-        }
-      }
-      break;
-    }
-  }
-}
-export {
-  renderQueue
-};

package/dist/runtime/server/render/queue/types.d.ts

@@ -1,81 +0,0 @@
-import type { SSRResult } from '../../../../types/public/internal.js';
-import type { AstroComponentInstance } from '../astro/instance.js';
-import type { RenderInstruction } from '../instruction.js';
-import type { ServerIslandComponent } from '../server-islands.js';
-import type { NodePool } from './pool.js';
-import type { HTMLStringCache } from '../../html-string-cache.js';
-/**
- * Text node containing plain text content that will be HTML-escaped during rendering
- */
-export interface TextNode {
-    type: 'text';
-    content: string;
-}
-/**
- * HTML string node containing pre-rendered HTML markup that is already safe
- */
-export interface HtmlStringNode {
-    type: 'html-string';
-    html: string;
-}
-/**
- * Component node containing an Astro component instance to be rendered
- */
-export interface ComponentNode {
-    type: 'component';
-    instance: AstroComponentInstance | ServerIslandComponent;
-}
-/**
- * Instruction node containing rendering instructions (head content, hydration scripts, etc.)
- */
-export interface InstructionNode {
-    type: 'instruction';
-    instruction: RenderInstruction;
-}
-/**
- * Discriminated union of all queue node types.
- * TypeScript will narrow the type based on the 'type' field.
- */
-export type QueueNode = TextNode | HtmlStringNode | ComponentNode | InstructionNode;
-/**
- * The render queue containing all nodes to be rendered
- */
-export interface RenderQueue {
-    /**
-     * All nodes in rendering order (after reversing the built queue)
-     */
-    nodes: QueueNode[];
-    /**
-     * SSRResult context
-     */
-    result: SSRResult;
-    /**
-     * Object pool instance used for node acquisition
-     */
-    pool?: NodePool;
-    /**
-     * HTMLString cache instance for reducing memory allocations
-     */
-    htmlStringCache?: HTMLStringCache;
-}
-/**
- * Stack item used during queue building (internal use only)
- */
-export interface StackItem {
-    /**
-     * The value to process
-     */
-    node: any;
-    /**
-     * Parent queue node (tracked but not used during rendering)
-     */
-    parent: QueueNode | null;
-    /**
-     * Additional metadata passed through the stack (component props, slots, displayName)
-     */
-    metadata?: {
-        displayName?: string;
-        props?: Record<string, any>;
-        slots?: any;
-    };
-}