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

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

@@ -1,203 +0,0 @@
-import { queuePoolSize } from "../../../../core/app/manifest.js";
-class NodePool {
-  textPool = [];
-  htmlStringPool = [];
-  componentPool = [];
-  instructionPool = [];
-  maxSize;
-  enableStats;
-  stats = {
-    acquireFromPool: 0,
-    acquireNew: 0,
-    released: 0,
-    releasedDropped: 0
-  };
-  /**
-   * Creates a new object pool for queue nodes.
-   *
-   * @param maxSize - Maximum number of nodes to keep in the pool (default: 1000).
-   *   The cap is shared across all typed sub-pools.
-   * @param enableStats - Enable statistics tracking (default: false for performance)
-   */
-  constructor(maxSize = 1e3, enableStats = false) {
-    this.maxSize = maxSize;
-    this.enableStats = enableStats;
-  }
-  /**
-   * Acquires a queue node from the pool or creates a new one if the pool is empty.
-   * Pops from the type-specific sub-pool to reuse an existing object when available.
-   *
-   * @param type - The type of queue node to acquire
-   * @param content - Optional content to set on the node (for text or html-string types)
-   * @returns A queue node ready to be populated with data
-   */
-  acquire(type, content) {
-    const pooledNode = this.popFromTypedPool(type);
-    if (pooledNode) {
-      if (this.enableStats) {
-        this.stats.acquireFromPool = this.stats.acquireFromPool + 1;
-      }
-      this.resetNodeContent(pooledNode, type, content);
-      return pooledNode;
-    }
-    if (this.enableStats) {
-      this.stats.acquireNew = this.stats.acquireNew + 1;
-    }
-    return this.createNode(type, content);
-  }
-  /**
-   * Creates a new node of the specified type with the given content.
-   * Helper method to reduce branching in acquire().
-   */
-  createNode(type, content = "") {
-    switch (type) {
-      case "text":
-        return { type: "text", content };
-      case "html-string":
-        return { type: "html-string", html: content };
-      case "component":
-        return { type: "component", instance: void 0 };
-      case "instruction":
-        return { type: "instruction", instruction: void 0 };
-    }
-  }
-  /**
-   * Pops a node from the type-specific sub-pool.
-   * Returns undefined if the sub-pool for the requested type is empty.
-   */
-  popFromTypedPool(type) {
-    switch (type) {
-      case "text":
-        return this.textPool.pop();
-      case "html-string":
-        return this.htmlStringPool.pop();
-      case "component":
-        return this.componentPool.pop();
-      case "instruction":
-        return this.instructionPool.pop();
-    }
-  }
-  /**
-   * Resets the content/value field on a reused pooled node.
-   * The type discriminant is already correct since we pop from the matching sub-pool.
-   */
-  resetNodeContent(node, type, content) {
-    switch (type) {
-      case "text":
-        node.content = content ?? "";
-        break;
-      case "html-string":
-        node.html = content ?? "";
-        break;
-      case "component":
-        node.instance = void 0;
-        break;
-      case "instruction":
-        node.instruction = void 0;
-        break;
-    }
-  }
-  /**
-   * Returns the total number of nodes across all typed sub-pools.
-   */
-  totalPoolSize() {
-    return this.textPool.length + this.htmlStringPool.length + this.componentPool.length + this.instructionPool.length;
-  }
-  /**
-   * Releases a queue node back to the pool for reuse.
-   * If the pool is at max capacity, the node is discarded (will be GC'd).
-   *
-   * @param node - The node to release back to the pool
-   */
-  release(node) {
-    if (this.totalPoolSize() >= this.maxSize) {
-      if (this.enableStats) {
-        this.stats.releasedDropped = this.stats.releasedDropped + 1;
-      }
-      return;
-    }
-    switch (node.type) {
-      case "text":
-        node.content = "";
-        this.textPool.push(node);
-        break;
-      case "html-string":
-        node.html = "";
-        this.htmlStringPool.push(node);
-        break;
-      case "component":
-        node.instance = void 0;
-        this.componentPool.push(node);
-        break;
-      case "instruction":
-        node.instruction = void 0;
-        this.instructionPool.push(node);
-        break;
-    }
-    if (this.enableStats) {
-      this.stats.released = this.stats.released + 1;
-    }
-  }
-  /**
-   * Releases all nodes in an array back to the pool.
-   * This is a convenience method for releasing multiple nodes at once.
-   *
-   * @param nodes - Array of nodes to release
-   */
-  releaseAll(nodes) {
-    for (const node of nodes) {
-      this.release(node);
-    }
-  }
-  /**
-   * Clears all typed sub-pools, discarding all cached nodes.
-   * This can be useful if you want to free memory after a large render.
-   */
-  clear() {
-    this.textPool.length = 0;
-    this.htmlStringPool.length = 0;
-    this.componentPool.length = 0;
-    this.instructionPool.length = 0;
-  }
-  /**
-   * Gets the current total number of nodes across all typed sub-pools.
-   * Useful for monitoring pool usage and tuning maxSize.
-   *
-   * @returns Number of nodes currently available in the pool
-   */
-  size() {
-    return this.totalPoolSize();
-  }
-  /**
-   * Gets pool statistics for debugging.
-   *
-   * @returns Pool usage statistics including computed metrics
-   */
-  getStats() {
-    return {
-      ...this.stats,
-      poolSize: this.totalPoolSize(),
-      maxSize: this.maxSize,
-      hitRate: this.stats.acquireFromPool + this.stats.acquireNew > 0 ? this.stats.acquireFromPool / (this.stats.acquireFromPool + this.stats.acquireNew) * 100 : 0
-    };
-  }
-  /**
-   * Resets pool statistics.
-   */
-  resetStats() {
-    this.stats = {
-      acquireFromPool: 0,
-      acquireNew: 0,
-      released: 0,
-      releasedDropped: 0
-    };
-  }
-}
-function newNodePool(config) {
-  const poolSize = queuePoolSize(config);
-  return new NodePool(poolSize);
-}
-export {
-  NodePool,
-  newNodePool
-};

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

@@ -1,12 +0,0 @@
-import { type RenderDestination } from '../common.js';
-import type { RenderQueue } from './types.js';
-/**
- * Renders a queue of nodes to a destination.
- * This function processes nodes sequentially with batching optimization.
- * Consecutive batchable nodes (text, HTML-string, simple elements) are
- * combined into a single write to reduce overhead.
- *
- * @param queue - The render queue to process
- * @param destination - Where to write the output
- */
-export declare function renderQueue(queue: RenderQueue, destination: RenderDestination): Promise<void>;

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;
-    };
-}