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

package/dist/runtime/server/html-string-cache.d.ts

@@ -1,48 +0,0 @@
-import { HTMLString } from './escape.js';
-/**
- * LRU (Least Recently Used) cache for HTMLString objects.
- *
- * This cache reduces memory allocations by reusing identical HTMLString objects
- * across both recursive rendering (.astro files) and queue rendering (MDX files).
- *
- * When the cache reaches maxSize, the least recently used item is evicted.
- * This keeps memory usage bounded while maintaining good cache hit rates.
- *
- * Example:
- * - 10,000 identical `<li class="foo">` tags → single cached HTMLString object
- * - Memory savings: ~30KB (10,000 objects) → ~3 bytes (1 object + Map overhead)
- */
-export declare class HTMLStringCache {
-    private cache;
-    private readonly maxSize;
-    constructor(maxSize?: number);
-    /**
-     * Get or create an HTMLString for the given content.
-     * If cached, the existing object is returned and moved to end (most recently used).
-     * If not cached, a new HTMLString is created, cached, and returned.
-     *
-     * @param content - The HTML string content
-     * @returns HTMLString object (cached or newly created)
-     */
-    getOrCreate(content: string): HTMLString;
-    /**
-     * Get current cache size
-     */
-    size(): number;
-    /**
-     * Pre-warms the cache with common HTML patterns.
-     * This ensures first-render cache hits for frequently used tags.
-     *
-     * @param patterns - Array of HTML strings to pre-cache
-     */
-    warm(patterns: string[]): void;
-    /**
-     * Clear the entire cache
-     */
-    clear(): void;
-}
-/**
- * Common HTML patterns that appear frequently in Astro pages.
- * Pre-warming the cache with these patterns ensures first-render cache hits.
- */
-export declare const COMMON_HTML_PATTERNS: string[];

package/dist/runtime/server/html-string-cache.js

@@ -1,119 +0,0 @@
-import { HTMLString } from "./escape.js";
-class HTMLStringCache {
-  cache = /* @__PURE__ */ new Map();
-  maxSize;
-  constructor(maxSize = 1e3) {
-    this.maxSize = maxSize;
-    this.warm(COMMON_HTML_PATTERNS);
-  }
-  /**
-   * Get or create an HTMLString for the given content.
-   * If cached, the existing object is returned and moved to end (most recently used).
-   * If not cached, a new HTMLString is created, cached, and returned.
-   *
-   * @param content - The HTML string content
-   * @returns HTMLString object (cached or newly created)
-   */
-  getOrCreate(content) {
-    const cached = this.cache.get(content);
-    if (cached) {
-      this.cache.delete(content);
-      this.cache.set(content, cached);
-      return cached;
-    }
-    const htmlString = new HTMLString(content);
-    this.cache.set(content, htmlString);
-    if (this.cache.size > this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== void 0) {
-        this.cache.delete(firstKey);
-      }
-    }
-    return htmlString;
-  }
-  /**
-   * Get current cache size
-   */
-  size() {
-    return this.cache.size;
-  }
-  /**
-   * Pre-warms the cache with common HTML patterns.
-   * This ensures first-render cache hits for frequently used tags.
-   *
-   * @param patterns - Array of HTML strings to pre-cache
-   */
-  warm(patterns) {
-    for (const pattern of patterns) {
-      if (!this.cache.has(pattern)) {
-        this.cache.set(pattern, new HTMLString(pattern));
-      }
-    }
-  }
-  /**
-   * Clear the entire cache
-   */
-  clear() {
-    this.cache.clear();
-  }
-}
-const COMMON_HTML_PATTERNS = [
-  // Structural elements
-  "<div>",
-  "</div>",
-  "<span>",
-  "</span>",
-  "<p>",
-  "</p>",
-  "<section>",
-  "</section>",
-  "<article>",
-  "</article>",
-  "<header>",
-  "</header>",
-  "<footer>",
-  "</footer>",
-  "<nav>",
-  "</nav>",
-  "<main>",
-  "</main>",
-  "<aside>",
-  "</aside>",
-  // List elements
-  "<ul>",
-  "</ul>",
-  "<ol>",
-  "</ol>",
-  "<li>",
-  "</li>",
-  // Void/self-closing elements
-  "<br>",
-  "<hr>",
-  "<br/>",
-  "<hr/>",
-  // Heading elements
-  "<h1>",
-  "</h1>",
-  "<h2>",
-  "</h2>",
-  "<h3>",
-  "</h3>",
-  "<h4>",
-  "</h4>",
-  // Inline elements
-  "<a>",
-  "</a>",
-  "<strong>",
-  "</strong>",
-  "<em>",
-  "</em>",
-  "<code>",
-  "</code>",
-  // Common whitespace
-  " ",
-  "\n"
-];
-export {
-  COMMON_HTML_PATTERNS,
-  HTMLStringCache
-};

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

@@ -1,14 +0,0 @@
-import type { SSRResult } from '../../../../types/public/internal.js';
-import type { RenderQueue } from './types.js';
-import type { NodePool } from './pool.js';
-/**
- * Builds a render queue from a component tree.
- * This function traverses the tree depth-first and creates a flat queue
- * of nodes to be rendered, with parent tracking.
- *
- * @param root - The root component/value to render
- * @param result - SSR result context
- * @param pool
- * @returns A render queue ready for rendering
- */
-export declare function buildRenderQueue(root: any, result: SSRResult, pool: NodePool): Promise<RenderQueue>;

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

@@ -1,182 +0,0 @@
-import { isPromise } from "../../util.js";
-import { isHTMLString, markHTMLString } from "../../escape.js";
-import { isAstroComponentFactory, isAPropagatingComponent } from "../astro/factory.js";
-import { createAstroComponentInstance, isAstroComponentInstance } from "../astro/instance.js";
-import { isRenderInstance } from "../common.js";
-import { isRenderInstruction } from "../instruction.js";
-import { SlotString } from "../slot.js";
-import { isRenderTemplateResult } from "../astro/render-template.js";
-import { isHeadAndContent } from "../astro/head-and-content.js";
-import { isVNode } from "../../../../jsx-runtime/index.js";
-import { renderJSXToQueue } from "./jsx-builder.js";
-async function buildRenderQueue(root, result, pool) {
-  const queue = {
-    nodes: [],
-    result,
-    pool,
-    htmlStringCache: result._experimentalQueuedRendering?.htmlStringCache
-  };
-  const stack = [{ node: root, parent: null }];
-  while (stack.length > 0) {
-    const item = stack.pop();
-    if (!item) {
-      continue;
-    }
-    let { node, parent } = item;
-    if (isPromise(node)) {
-      try {
-        const resolved = await node;
-        stack.push({ node: resolved, parent, metadata: item.metadata });
-      } catch (error) {
-        throw error;
-      }
-      continue;
-    }
-    if (node == null || node === false) {
-      continue;
-    }
-    if (typeof node === "string") {
-      const queueNode = pool.acquire("text", node);
-      queueNode.content = node;
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (typeof node === "number" || typeof node === "boolean") {
-      const str = String(node);
-      const queueNode = pool.acquire("text", str);
-      queueNode.content = str;
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (isHTMLString(node)) {
-      const html = node.toString();
-      const queueNode = pool.acquire("html-string", html);
-      queueNode.html = html;
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (node instanceof SlotString) {
-      const html = node.toString();
-      const queueNode = pool.acquire("html-string", html);
-      queueNode.html = html;
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (isVNode(node)) {
-      renderJSXToQueue(node, result, queue, pool, stack, parent, item.metadata);
-      continue;
-    }
-    if (Array.isArray(node)) {
-      for (const n of node) {
-        stack.push({ node: n, parent, metadata: item.metadata });
-      }
-      continue;
-    }
-    if (isRenderInstruction(node)) {
-      const queueNode = pool.acquire("instruction");
-      queueNode.instruction = node;
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (isRenderTemplateResult(node)) {
-      const htmlParts = node["htmlParts"];
-      const expressions = node["expressions"];
-      if (htmlParts[0]) {
-        const htmlString = queue.htmlStringCache ? queue.htmlStringCache.getOrCreate(htmlParts[0]) : markHTMLString(htmlParts[0]);
-        stack.push({
-          node: htmlString,
-          parent,
-          metadata: item.metadata
-        });
-      }
-      for (let i = 0; i < expressions.length; i = i + 1) {
-        stack.push({ node: expressions[i], parent, metadata: item.metadata });
-        if (htmlParts[i + 1]) {
-          const htmlString = queue.htmlStringCache ? queue.htmlStringCache.getOrCreate(htmlParts[i + 1]) : markHTMLString(htmlParts[i + 1]);
-          stack.push({
-            node: htmlString,
-            parent,
-            metadata: item.metadata
-          });
-        }
-      }
-      continue;
-    }
-    if (isAstroComponentInstance(node)) {
-      const queueNode = pool.acquire("component");
-      queueNode.instance = node;
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (isAstroComponentFactory(node)) {
-      const factory = node;
-      const props = item.metadata?.props || {};
-      const slots = item.metadata?.slots || {};
-      const displayName = item.metadata?.displayName || factory.name || "Anonymous";
-      const instance = createAstroComponentInstance(result, displayName, factory, props, slots);
-      const queueNode = pool.acquire("component");
-      queueNode.instance = instance;
-      if (isAPropagatingComponent(result, factory)) {
-        try {
-          const returnValue = await instance.init(result);
-          if (isHeadAndContent(returnValue) && returnValue.head) {
-            result._metadata.extraHead.push(returnValue.head);
-          }
-        } catch (error) {
-          throw error;
-        }
-      }
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (isRenderInstance(node)) {
-      const queueNode = pool.acquire("component");
-      queueNode.instance = node;
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (typeof node === "object" && Symbol.iterator in node) {
-      const items = Array.from(node);
-      for (const iterItem of items) {
-        stack.push({ node: iterItem, parent, metadata: item.metadata });
-      }
-      continue;
-    }
-    if (typeof node === "object" && Symbol.asyncIterator in node) {
-      try {
-        const items = [];
-        for await (const asyncItem of node) {
-          items.push(asyncItem);
-        }
-        for (const iterItem of items) {
-          stack.push({ node: iterItem, parent, metadata: item.metadata });
-        }
-      } catch (error) {
-        throw error;
-      }
-      continue;
-    }
-    if (node instanceof Response) {
-      const queueNode = pool.acquire("html-string", "");
-      queueNode.html = "";
-      queue.nodes.push(queueNode);
-      continue;
-    }
-    if (isHTMLString(node)) {
-      const html = String(node);
-      const queueNode = pool.acquire("html-string", html);
-      queueNode.html = html;
-      queue.nodes.push(queueNode);
-    } else {
-      const str = String(node);
-      const queueNode = pool.acquire("text", str);
-      queueNode.content = str;
-      queue.nodes.push(queueNode);
-    }
-  }
-  queue.nodes.reverse();
-  return queue;
-}
-export {
-  buildRenderQueue
-};

package/dist/runtime/server/render/queue/jsx-builder.d.ts

@@ -1,33 +0,0 @@
-import type { SSRResult } from '../../../../types/public/internal.js';
-import type { RenderQueue, StackItem, QueueNode } from './types.js';
-import type { NodePool } from './pool.js';
-/**
- * Get JSX queue rendering statistics
- */
-export declare function getJSXQueueStats(): {
-    vnodeCount: number;
-    elementCount: number;
-    componentCount: number;
-    hasLogged: boolean;
-};
-/**
- * Reset JSX queue rendering statistics
- */
-export declare function resetJSXQueueStats(): void;
-/**
- * Processes JSX VNodes and adds them to the render queue.
- * Unlike renderJSX(), this doesn't build strings recursively -
- * it pushes nodes directly to the queue for batching and memory efficiency.
- *
- * This function handles JSX created by astro:jsx (JSX in .astro files).
- * It converts VNodes to queue nodes, enabling content-aware pooling and batching.
- *
- * @param vnode - JSX VNode to process
- * @param result - SSR result context
- * @param queue - Queue to append nodes to
- * @param pool - Node pool for memory efficiency
- * @param stack - Stack for depth-first traversal
- * @param parent - Parent queue node (for tracking)
- * @param metadata - Metadata passed through stack (props, slots, displayName)
- */
-export declare function renderJSXToQueue(vnode: any, result: SSRResult, queue: RenderQueue, pool: NodePool, stack: StackItem[], parent: QueueNode | null, metadata?: StackItem['metadata']): void;

package/dist/runtime/server/render/queue/jsx-builder.js

@@ -1,146 +0,0 @@
-import { isVNode } from "../../../../jsx-runtime/index.js";
-import { HTMLString, markHTMLString, spreadAttributes, voidElementNames } from "../../index.js";
-import { isAstroComponentFactory } from "../astro/factory.js";
-import { createAstroComponentInstance } from "../astro/instance.js";
-import { renderJSX } from "../../jsx.js";
-const ClientOnlyPlaceholder = "astro-client-only";
-let jsxQueueStats = {
-  vnodeCount: 0,
-  elementCount: 0,
-  componentCount: 0,
-  hasLogged: false
-};
-function getJSXQueueStats() {
-  return { ...jsxQueueStats };
-}
-function resetJSXQueueStats() {
-  jsxQueueStats = {
-    vnodeCount: 0,
-    elementCount: 0,
-    componentCount: 0,
-    hasLogged: false
-  };
-}
-function renderJSXToQueue(vnode, result, queue, pool, stack, parent, metadata) {
-  jsxQueueStats.vnodeCount = jsxQueueStats.vnodeCount + 1;
-  if (vnode instanceof HTMLString) {
-    const html = vnode.toString();
-    if (html.trim() === "") return;
-    const node = pool.acquire("html-string", html);
-    node.html = html;
-    queue.nodes.push(node);
-    return;
-  }
-  if (typeof vnode === "string") {
-    const node = pool.acquire("text", vnode);
-    node.content = vnode;
-    queue.nodes.push(node);
-    return;
-  }
-  if (typeof vnode === "number" || typeof vnode === "boolean") {
-    const str = String(vnode);
-    const node = pool.acquire("text", str);
-    node.content = str;
-    queue.nodes.push(node);
-    return;
-  }
-  if (vnode == null || vnode === false) {
-    return;
-  }
-  if (Array.isArray(vnode)) {
-    for (let i = vnode.length - 1; i >= 0; i = i - 1) {
-      stack.push({ node: vnode[i], parent, metadata });
-    }
-    return;
-  }
-  if (!isVNode(vnode)) {
-    const str = String(vnode);
-    const node = pool.acquire("text", str);
-    node.content = str;
-    queue.nodes.push(node);
-    return;
-  }
-  handleVNode(vnode, result, queue, pool, stack, parent, metadata);
-}
-function handleVNode(vnode, result, queue, pool, stack, parent, metadata) {
-  if (!vnode.type) {
-    throw new Error(
-      `Unable to render ${result.pathname} because it contains an undefined Component!
-Did you forget to import the component or is it possible there is a typo?`
-    );
-  }
-  if (vnode.type === /* @__PURE__ */ Symbol.for("astro:fragment")) {
-    stack.push({ node: vnode.props?.children, parent, metadata });
-    return;
-  }
-  if (isAstroComponentFactory(vnode.type)) {
-    jsxQueueStats.componentCount = jsxQueueStats.componentCount + 1;
-    const factory = vnode.type;
-    let props = {};
-    let slots = {};
-    for (const [key, value] of Object.entries(vnode.props ?? {})) {
-      if (key === "children" || value && typeof value === "object" && value["$$slot"]) {
-        slots[key === "children" ? "default" : key] = () => renderJSX(result, value);
-      } else {
-        props[key] = value;
-      }
-    }
-    const displayName = metadata?.displayName || factory.name || "Anonymous";
-    const instance = createAstroComponentInstance(result, displayName, factory, props, slots);
-    const queueNode = pool.acquire("component");
-    queueNode.instance = instance;
-    queue.nodes.push(queueNode);
-    return;
-  }
-  if (typeof vnode.type === "string" && vnode.type !== ClientOnlyPlaceholder) {
-    jsxQueueStats.elementCount = jsxQueueStats.elementCount + 1;
-    renderHTMLElement(vnode, result, queue, pool, stack, parent, metadata);
-    return;
-  }
-  if (typeof vnode.type === "function") {
-    if (vnode.props?.["server:root"]) {
-      const output3 = vnode.type(vnode.props ?? {});
-      stack.push({ node: output3, parent, metadata });
-      return;
-    }
-    const output2 = vnode.type(vnode.props ?? {});
-    stack.push({ node: output2, parent, metadata });
-    return;
-  }
-  const output = renderJSX(result, vnode);
-  stack.push({ node: output, parent, metadata });
-}
-function renderHTMLElement(vnode, _result, queue, pool, stack, parent, metadata) {
-  const tag = vnode.type;
-  const { children, ...props } = vnode.props ?? {};
-  const attrs = spreadAttributes(props);
-  const isVoidElement = (children == null || children === "") && voidElementNames.test(tag);
-  if (isVoidElement) {
-    const html = `<${tag}${attrs}/>`;
-    const node = pool.acquire("html-string", html);
-    node.html = html;
-    queue.nodes.push(node);
-    return;
-  }
-  const openTag = `<${tag}${attrs}>`;
-  const openTagHtml = queue.htmlStringCache ? queue.htmlStringCache.getOrCreate(openTag) : markHTMLString(openTag);
-  stack.push({ node: openTagHtml, parent, metadata });
-  if (children != null && children !== "") {
-    const processedChildren = prerenderElementChildren(tag, children, queue.htmlStringCache);
-    stack.push({ node: processedChildren, parent, metadata });
-  }
-  const closeTag = `</${tag}>`;
-  const closeTagHtml = queue.htmlStringCache ? queue.htmlStringCache.getOrCreate(closeTag) : markHTMLString(closeTag);
-  stack.push({ node: closeTagHtml, parent, metadata });
-}
-function prerenderElementChildren(tag, children, htmlStringCache) {
-  if (typeof children === "string" && (tag === "style" || tag === "script")) {
-    return htmlStringCache ? htmlStringCache.getOrCreate(children) : markHTMLString(children);
-  }
-  return children;
-}
-export {
-  getJSXQueueStats,
-  renderJSXToQueue,
-  resetJSXQueueStats
-};

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

@@ -1,123 +0,0 @@
-import type { QueueNode } from './types.js';
-import type { SSRManifest } from '../../../../core/app/types.js';
-/**
- * Raw statistics tracked by the node pool.
- */
-export interface PoolStats {
-    /** Number of times a node was successfully acquired from the pool */
-    acquireFromPool: number;
-    /** Number of times a new node had to be created (pool was empty) */
-    acquireNew: number;
-    /** Number of nodes successfully returned to the pool */
-    released: number;
-    /** Number of nodes that couldn't be returned (pool was full) */
-    releasedDropped: number;
-}
-/**
- * Extended statistics report with computed metrics.
- * Returned by NodePool.getStats() for debugging and monitoring.
- */
-export interface PoolStatsReport extends PoolStats {
-    /** Current number of nodes available in the pool */
-    poolSize: number;
-    /** Maximum pool capacity */
-    maxSize: number;
-    /** Pool hit rate as a percentage (0-100) - higher is better */
-    hitRate: number;
-}
-/**
- * Object pool for `QueueNode` instances to reduce allocations and GC pressure.
- *
- * Uses type-aware sub-pools so that released nodes are reused by the same
- * node type, preserving V8 hidden classes and avoiding shape transitions.
- * Nodes are acquired from the pool, used during queue building, and released
- * back to the pool for reuse across renders.
- *
- * String deduplication is handled separately by `HTMLStringCache`.
- */
-export declare class NodePool {
-    private textPool;
-    private htmlStringPool;
-    private componentPool;
-    private instructionPool;
-    readonly maxSize: number;
-    private readonly enableStats;
-    private stats;
-    /**
-     * 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?: number, enableStats?: boolean);
-    /**
-     * 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: QueueNode['type'], content?: string): QueueNode;
-    /**
-     * Creates a new node of the specified type with the given content.
-     * Helper method to reduce branching in acquire().
-     */
-    private createNode;
-    /**
-     * Pops a node from the type-specific sub-pool.
-     * Returns undefined if the sub-pool for the requested type is empty.
-     */
-    private popFromTypedPool;
-    /**
-     * Resets the content/value field on a reused pooled node.
-     * The type discriminant is already correct since we pop from the matching sub-pool.
-     */
-    private resetNodeContent;
-    /**
-     * Returns the total number of nodes across all typed sub-pools.
-     */
-    private totalPoolSize;
-    /**
-     * 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: QueueNode): void;
-    /**
-     * 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: QueueNode[]): void;
-    /**
-     * Clears all typed sub-pools, discarding all cached nodes.
-     * This can be useful if you want to free memory after a large render.
-     */
-    clear(): void;
-    /**
-     * 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(): number;
-    /**
-     * Gets pool statistics for debugging.
-     *
-     * @returns Pool usage statistics including computed metrics
-     */
-    getStats(): PoolStatsReport;
-    /**
-     * Resets pool statistics.
-     */
-    resetStats(): void;
-}
-/**
- * Returns an instance of the `NodePool` based on its configuration.
- * @param config - The queued rendering configuration from the SSR manifest
- */
-export declare function newNodePool(config: NonNullable<SSRManifest['experimentalQueuedRendering']>): NodePool;