npm - astro - Versions diffs - 7.0.0-alpha.2 → 7.0.0-beta.3 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

package/dist/assets/fonts/core/collect-font-data.js +1 -0
package/dist/assets/fonts/types.d.ts +1 -0
package/dist/cli/add/index.js +0 -44
package/dist/cli/dev/background.js +1 -1
package/dist/cli/dev/index.js +1 -1
package/dist/cli/flags.js +4 -6
package/dist/cli/help/index.js +1 -2
package/dist/cli/index.js +1 -15
package/dist/cli/infra/build-time-astro-version-provider.js +1 -1
package/dist/container/index.js +1 -4
package/dist/content/content-layer.js +3 -3
package/dist/core/app/base.d.ts +1 -1
package/dist/core/app/base.js +7 -9
package/dist/core/app/dev/pipeline.js +0 -9
package/dist/core/app/manifest.d.ts +0 -2
package/dist/core/app/manifest.js +0 -8
package/dist/core/app/types.d.ts +1 -8
package/dist/core/base-pipeline.d.ts +3 -9
package/dist/core/base-pipeline.js +4 -23
package/dist/core/build/app.d.ts +0 -2
package/dist/core/build/app.js +0 -5
package/dist/core/build/generate.js +0 -14
package/dist/core/build/pipeline.js +0 -9
package/dist/core/build/plugins/plugin-manifest.js +4 -9
package/dist/core/config/config.js +3 -2
package/dist/core/config/schemas/base.d.ts +6 -19
package/dist/core/config/schemas/base.js +8 -24
package/dist/core/config/schemas/relative.d.ts +15 -36
package/dist/core/constants.js +1 -1
package/dist/core/dev/dev.js +1 -1
package/dist/core/fetch/fetch-state.js +0 -14
package/dist/core/fetch/types.d.ts +1 -1
package/dist/core/fetch/vite-plugin.js +4 -6
package/dist/core/hono/index.d.ts +1 -0
package/dist/core/hono/index.js +1 -0
package/dist/core/logger/impls/node.js +0 -1
package/dist/core/logger/load.js +3 -2
package/dist/core/messages/runtime.js +1 -1
package/dist/core/middleware/index.js +8 -1
package/dist/manifest/serialized.js +4 -5
package/dist/runtime/server/index.d.ts +1 -1
package/dist/runtime/server/index.js +4 -0
package/dist/runtime/server/render/astro/render-template.d.ts +1 -1
package/dist/runtime/server/render/astro/render.d.ts +0 -4
package/dist/runtime/server/render/astro/render.js +76 -68
package/dist/runtime/server/render/index.d.ts +1 -0
package/dist/runtime/server/render/index.js +2 -0
package/dist/runtime/server/render/page.js +9 -44
package/dist/runtime/server/render/streaming.d.ts +23 -0
package/dist/runtime/server/render/streaming.js +238 -0
package/dist/runtime/server/render/util.js +1 -1
package/dist/types/public/config.d.ts +58 -121
package/dist/types/public/context.d.ts +1 -1
package/dist/types/public/internal.d.ts +0 -15
package/dist/vite-plugin-app/app.js +1 -1
package/dist/vite-plugin-app/pipeline.js +0 -9
package/package.json +1 -1
package/dist/cli/db/index.d.ts +0 -4
package/dist/cli/db/index.js +0 -25
package/dist/runtime/server/html-string-cache.d.ts +0 -48
package/dist/runtime/server/html-string-cache.js +0 -119
package/dist/runtime/server/render/queue/builder.d.ts +0 -14
package/dist/runtime/server/render/queue/builder.js +0 -182
package/dist/runtime/server/render/queue/jsx-builder.d.ts +0 -33
package/dist/runtime/server/render/queue/jsx-builder.js +0 -146
package/dist/runtime/server/render/queue/pool.d.ts +0 -123
package/dist/runtime/server/render/queue/pool.js +0 -203
package/dist/runtime/server/render/queue/renderer.d.ts +0 -12
package/dist/runtime/server/render/queue/renderer.js +0 -103
package/dist/runtime/server/render/queue/types.d.ts +0 -81
package/dist/runtime/server/render/queue/types.js +0 -0

package/dist/runtime/server/render/page.js CHANGED Viewed

@@ -1,57 +1,22 @@
 import { renderToAsyncIterable, renderToReadableStream, renderToString } from "./astro/render.js";
 import { encoder } from "./common.js";
 import { renderComponentToString } from "./component.js";
-import { markHTMLString } from "../escape.js";
 import { renderCspContent } from "./csp.js";
 import { isDeno, isNode } from "./util.js";
 import { isAstroComponentFactory } from "./astro/factory.js";
-import { buildRenderQueue } from "./queue/builder.js";
-import { renderQueue } from "./queue/renderer.js";
-import { chunkToString } from "./common.js";
 async function renderPage(result, componentFactory, props, children, streaming, route) {
   if (!isAstroComponentFactory(componentFactory)) {
     result._metadata.headInTree = result.componentMetadata.get(componentFactory.moduleId)?.containsHead ?? false;
     const pageProps = { ...props ?? {}, "server:root": true };
-    let str;
-    if (result._experimentalQueuedRendering && result._experimentalQueuedRendering.enabled) {
-      let vnode = await componentFactory(pageProps);
-      if (componentFactory["astro:html"] && typeof vnode === "string") {
-        vnode = markHTMLString(vnode);
-      }
-      const queue = await buildRenderQueue(
-        vnode,
-        result,
-        result._experimentalQueuedRendering.pool
-      );
-      let html = "";
-      let renderedFirst = false;
-      const destination = {
-        write(chunk) {
-          if (chunk instanceof Response) return;
-          if (!renderedFirst && !result.partial) {
-            renderedFirst = true;
-            const chunkStr = String(chunk);
-            if (!/<!doctype html/i.test(chunkStr)) {
-              const doctype = result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n";
-              html += doctype;
-            }
-          }
-          html += chunkToString(result, chunk);
-        }
-      };
-      await renderQueue(queue, destination);
-      str = html;
-    } else {
-      str = await renderComponentToString(
-        result,
-        componentFactory.name,
-        componentFactory,
-        pageProps,
-        {},
-        true,
-        route
-      );
-    }
+    const str = await renderComponentToString(
+      result,
+      componentFactory.name,
+      componentFactory,
+      pageProps,
+      {},
+      true,
+      route
+    );
     const bytes = encoder.encode(str);
     const headers2 = new Headers([
       ["Content-Type", "text/html"],

package/dist/runtime/server/render/streaming.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import type { SSRResult } from '../../../types/public/internal.js';
+import { type RenderDestination } from './common.js';
+/**
+ * Streaming render engine.
+ *
+ * Walks the component tree in a single forward pass (explicit stack), batching
+ * consecutive static fragments into one write. The static structure
+ * (RenderTemplateResult HTML parts, arrays, primitives) never allocates a node
+ * object and never wraps HTML parts in `markHTMLString`, so static-heavy pages
+ * render with minimal overhead.
+ *
+ * Dynamic subtrees (components, render instances, promises, JSX) are rendered
+ * via `renderChild`. While their output stays synchronous, the engine streams
+ * it straight to `destination`. As soon as a dynamic node renders
+ * asynchronously, the engine switches to a buffered tail: every remaining
+ * dynamic node is started eagerly (so async work runs in parallel) and the
+ * buffers are flushed in order. This mirrors `RenderTemplateResult.render`, so
+ * async components render concurrently rather than serially.
+ *
+ * Head propagation is handled by the caller (`bufferHeadContent`) before this
+ * runs.
+ */
+export declare function renderStreaming(root: unknown, result: SSRResult, destination: RenderDestination): Promise<void>;

package/dist/runtime/server/render/streaming.js ADDED Viewed

@@ -0,0 +1,238 @@
+import { isVNode } from "../../../jsx-runtime/index.js";
+import { escapeHTML, HTMLString, isHTMLString, markHTMLString } from "../escape.js";
+import { spreadAttributes } from "../index.js";
+import { isPromise } from "../util.js";
+import { renderJSX } from "../jsx.js";
+import { renderChild } from "./any.js";
+import { Fragment } from "./common.js";
+import { createBufferedRenderer, voidElementNames } from "./util.js";
+import { isAstroComponentFactory } from "./astro/factory.js";
+import { createAstroComponentInstance } from "./astro/instance.js";
+import { isRenderTemplateResult } from "./astro/render-template.js";
+import { containsServerDirective, ServerIslandComponent } from "./server-islands.js";
+const ClientOnlyPlaceholder = "astro-client-only";
+class TemplateFrame {
+  /** The RenderTemplateResult this frame walks. */
+  templateResult;
+  /** Resume position: the next `htmlParts`/`expressions` index to process. */
+  cursor;
+  constructor(templateResult) {
+    this.templateResult = templateResult;
+    this.cursor = 0;
+  }
+  storeCursor(index) {
+    this.cursor = index;
+  }
+}
+async function renderStreaming(root, result, destination) {
+  const stack = [root];
+  const openTagCache = /* @__PURE__ */ new Map();
+  const closeTagCache = /* @__PURE__ */ new Map();
+  const closeTagFor = (type) => {
+    let tag = closeTagCache.get(type);
+    if (tag === void 0) {
+      tag = new HTMLString(`</${type}>`);
+      closeTagCache.set(type, tag);
+    }
+    return tag;
+  };
+  let batch = "";
+  let buffered = false;
+  let firstAsync = null;
+  const tail = [];
+  let tailStatic = "";
+  const emitStatic = (s) => {
+    if (!s) return;
+    if (buffered) tailStatic += s;
+    else batch += s;
+  };
+  const flushTailStatic = () => {
+    if (tailStatic) {
+      tail.push(tailStatic);
+      tailStatic = "";
+    }
+  };
+  const renderDynamic = (node) => (d) => {
+    if (isVNode(node)) {
+      return renderJSX(result, node).then((out) => renderChild(d, out));
+    }
+    return renderChild(d, node);
+  };
+  const handleVNode = (vnode) => {
+    const type = vnode.type;
+    if (!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 (type === Fragment) {
+      stack.push(vnode.props?.children);
+      return;
+    }
+    if (isAstroComponentFactory(type)) {
+      const props = {};
+      const 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 = type.name || "Anonymous";
+      if (containsServerDirective(props)) {
+        const island = new ServerIslandComponent(result, props, slots, displayName);
+        result._metadata.propagators.add(island);
+        stack.push(island);
+        return;
+      }
+      stack.push(createAstroComponentInstance(result, displayName, type, props, slots));
+      return;
+    }
+    if (typeof type === "string" && type !== ClientOnlyPlaceholder) {
+      const props = vnode.props;
+      let hasAttrs = false;
+      if (props) {
+        for (const key in props) {
+          if (key !== "children") {
+            hasAttrs = true;
+            break;
+          }
+        }
+      }
+      const children = props?.children;
+      const isVoid = (children == null || children === "") && voidElementNames.test(type);
+      if (!hasAttrs) {
+        const key = isVoid ? `${type}/` : type;
+        let openTag = openTagCache.get(key);
+        if (openTag === void 0) {
+          openTag = isVoid ? `<${type}/>` : `<${type}>`;
+          openTagCache.set(key, openTag);
+        }
+        emitStatic(openTag);
+        if (!isVoid) {
+          stack.push(closeTagFor(type));
+        }
+      } else {
+        const { children: _children, ...attrsProps } = props ?? {};
+        const attrs = spreadAttributes(attrsProps);
+        if (isVoid) {
+          emitStatic(`<${type}${attrs}/>`);
+          return;
+        }
+        emitStatic(`<${type}${attrs}>`);
+        stack.push(markHTMLString(`</${type}>`));
+      }
+      if (!isVoid && children != null && children !== "") {
+        if (typeof children === "string" && (type === "style" || type === "script")) {
+          stack.push(markHTMLString(children));
+        } else {
+          stack.push(children);
+        }
+      }
+      return;
+    }
+    if (typeof type === "function" && vnode.props?.["server:root"]) {
+      stack.push(type(vnode.props ?? {}));
+      return;
+    }
+    stack.push(renderJSX(result, vnode));
+  };
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node == null || node === false) continue;
+    if (node instanceof TemplateFrame) {
+      const htmlParts = node.templateResult.htmlParts;
+      const expressions = node.templateResult.expressions;
+      let i = node.cursor;
+      while (i < htmlParts.length) {
+        if (htmlParts[i]) {
+          emitStatic(htmlParts[i]);
+        }
+        if (i >= expressions.length) {
+          break;
+        }
+        const expression = expressions[i];
+        i++;
+        if (expression == null || expression === false) continue;
+        const expressionType = typeof expression;
+        if (expressionType === "string") {
+          emitStatic(escapeHTML(expression));
+          continue;
+        }
+        if (expressionType === "number" || expressionType === "bigint" || expressionType === "boolean") {
+          emitStatic(String(expression));
+          continue;
+        }
+        if (expression instanceof HTMLString || isHTMLString(expression)) {
+          emitStatic(expression.toString());
+          continue;
+        }
+        node.storeCursor(i);
+        stack.push(node);
+        stack.push(expression);
+        break;
+      }
+      continue;
+    }
+    const nodeType = typeof node;
+    if (nodeType === "string") {
+      emitStatic(escapeHTML(node));
+      continue;
+    }
+    if (nodeType === "number" || nodeType === "bigint" || nodeType === "boolean") {
+      emitStatic(String(node));
+      continue;
+    }
+    if (node instanceof HTMLString || isHTMLString(node)) {
+      emitStatic(node.toString());
+      continue;
+    }
+    if (Array.isArray(node)) {
+      for (let i = node.length - 1; i >= 0; i--) stack.push(node[i]);
+      continue;
+    }
+    if (isRenderTemplateResult(node)) {
+      stack.push(new TemplateFrame(node));
+      continue;
+    }
+    if (isVNode(node)) {
+      handleVNode(node);
+      continue;
+    }
+    if (!buffered) {
+      if (batch) {
+        destination.write(markHTMLString(batch));
+        batch = "";
+      }
+      const rendered = renderDynamic(node)(destination);
+      if (isPromise(rendered)) {
+        buffered = true;
+        firstAsync = rendered;
+      }
+    } else {
+      flushTailStatic();
+      tail.push(createBufferedRenderer(destination, renderDynamic(node)));
+    }
+  }
+  if (!buffered) {
+    if (batch) {
+      destination.write(markHTMLString(batch));
+    }
+    return;
+  }
+  await firstAsync;
+  flushTailStatic();
+  for (const seg of tail) {
+    if (typeof seg === "string") {
+      destination.write(markHTMLString(seg));
+    } else {
+      const r = seg.flush();
+      if (isPromise(r)) await r;
+    }
+  }
+}
+export {
+  renderStreaming
+};

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

@@ -149,7 +149,7 @@ class BufferedRenderer {
 function createBufferedRenderer(destination, renderFunction) {
   return new BufferedRenderer(destination, renderFunction);
 }
-const isNode = typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]" && !(typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers");
+const isNode = typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]";
 const isDeno = typeof Deno !== "undefined";
 function promiseWithResolvers() {
   let resolve, reject;

package/dist/types/public/config.d.ts CHANGED Viewed

@@ -1321,6 +1321,64 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
     server?: ServerConfig | ((options: {
         command: 'dev' | 'preview';
     }) => ServerConfig);
+    /**
+     * @docs
+     * @kind heading
+     * @name fetchFile
+     * @type {string | null}
+     * @default `'fetch'`
+     * @version 7.0.0
+     * @description
+     *
+     * Customizes the file used as the fetch entrypoint inside `srcDir`.
+     * Defaults to `'fetch'`, meaning Astro looks for `src/fetch.ts` (or `.js` / `.mjs` / `.mts`).
+     *
+     * The fetch file allows you to compose Astro's request pipeline with the
+     * Web Fetch standard or your own Hono middleware.
+     *
+     * If you already have a `src/fetch.ts` file in use for other purposes, define a
+     * different filename or set the value to `null` to disable the entrypoint:
+     *
+     * ```js
+     * // astro.config.mjs
+     * import { defineConfig } from 'astro/config';
+     *
+     * export default defineConfig({
+     *   fetchFile: 'handler',
+     * });
+     * ```
+     *
+     * Learn more about customizing the request pipeline in the [advanced routing guide](https://docs.astro.build/en/guides/routing/#advanced-routing).
+     */
+    fetchFile?: string | null;
+    /**
+     * @docs
+     * @kind heading
+     * @name Logger Options
+     * @type {LoggerHandlerConfig}
+     * @default `undefined`
+     * @version 7.0.0
+     * @description
+     *
+     * Configures a custom logger by defining its entrypoint and, optionally, providing a serializable configuration:
+     *
+     * ```js
+     * // astro.config.mjs
+     * import { defineConfig } from 'astro/config';
+     *
+     * export default defineConfig({
+     *   logger: {
+     *     entrypoint: "@org/astro-logger",
+     *     config: {
+     *      level: "error"
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * See [the logger API reference](https://docs.astro.build/en/reference/logger-reference/) for more information.
+     */
+    logger?: LoggerHandlerConfig;
     /**
      * @docs
      * @kind heading
@@ -2676,40 +2734,6 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      * These flags are not guaranteed to be stable.
      */
     experimental?: {
-        /**
-         * @name experimental.advancedRouting
-         * @type {boolean | object}
-         * @default `false`
-         * @description
-         * Enables `src/app.ts` as an advanced routing entrypoint, allowing you to
-         * compose Astro's request pipeline with the Web Fetch standard or your own Hono middleware.
-         *
-         * Pass `true` to enable with default settings, or an object to customize:
-         *
-         * ```js
-         * export default defineConfig({
-         *   experimental: {
-         *     advancedRouting: {
-         *       fetchFile: 'fetch.ts',
-         *     },
-         *   },
-         * });
-         * ```
-         */
-        advancedRouting?: boolean | {
-            /**
-             * @name experimental.advancedRouting.fetchFile
-             * @type {string | null}
-             * @default 'app'
-             * @description
-             *
-             * Customizes the file used as the advanced routing entrypoint inside `srcDir`.
-             * Defaults to `'app'`, meaning Astro looks for `src/app.ts`.
-             *
-             * If you already have a `src/app.ts` file in use for other purposes, define a different filename or set the value to `null` to disable the entrypoint.
-             */
-            fetchFile?: string | null;
-        };
         /**
          *
          * @name experimental.clientPrerender
@@ -2893,93 +2917,6 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
          * ```
          */
         routeRules?: RouteRules;
-        /**
-         * @name experimental.queuedRendering
-         * @type {boolean | { poolSize?: number; cache?: boolean }}
-         * @default `false`
-         * @version 6.0.0
-         * @description
-         * Enable queue-based rendering engine instead of the default recursive rendering.
-         *
-         * This new rendering engine comes with a different set of features that you can tweak based on your needs.
-         *
-         * ```js
-         * {
-         *   experimental: {
-         *     queuedRendering: {
-         *       enabled: true
-         *     }
-         *   }
-         * }
-         * ```
-         *
-         * You can optionally configure the object pool size and HTMLString caching:
-         *
-         * ```js
-         * {
-         *   experimental: {
-         *     queuedRendering: {
-         *       enabled: true,
-         *       poolSize: 1000,  // default: 1000 for static builds, 0 for SSR
-         *       cache: false     // default: false (caching can hurt performance)
-         *     }
-         *   }
-         * }
-         * ```
-         */
-        queuedRendering?: {
-            /**
-             * @default `false`
-             * @version 6.0.0
-             * @description
-             * Enables the queue-based rendering.
-             */
-            enabled: boolean;
-            /**
-             * @default 1000
-             * @version 6.0.0
-             * @description
-             * Allows to change how many nodes should be saved in the pool. If 0 is provided, the pool is disabled.
-             * The pool is disabled for dynamic pages, because server requests don't share the same memory.
-             */
-            poolSize?: number;
-            /**
-             * @default `false`
-             * @version 6.0.0
-             * @description
-             * Enables HTMLString caching to deduplicate repeated HTML fragments during rendering.
-             * When enabled, identical HTML strings (e.g., repeated `<li>` tags) share a single
-             * `HTMLString` object instead of creating a new wrapper per occurrence.
-             * This caching is disabled for dynamic pages.
-             */
-            contentCache?: boolean;
-        };
-        /**
-         * @name experimental.logger
-         * @type {{ entrypoint: string; config?: Record<string, unknown> }}
-         * @default `undefined`
-         * @version 6.2.0
-         * @description
-         *
-         * Configure a custom logger by defining its entrypoint and, optionally, providing a serializable configuration:
-         *
-         * ```js
-         * // astro.config.mjs
-         * import { defineConfig } from 'astro/config';
-         *
-         * export default defineConfig({
-         *   experimental: {
-         *     logger: {
-         *       entrypoint: "@org/astro-logger",
-         *       config: {
-         *        level: "error"
-         *       }
-         *     }
-         *   }
-         * });
-         * ```
-         */
-        logger?: LoggerHandlerConfig;
     };
 }
 /**

package/dist/types/public/context.d.ts CHANGED Viewed

@@ -546,7 +546,7 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
          * Logs a message with `error` level.
          */
         error: (msg: string) => void;
-    } | undefined;
+    };
     /**
      * The route currently rendered. It's stripped of the `srcDir` and the `pages` folder, and it doesn't contain the extension.
      *

package/dist/types/public/internal.d.ts CHANGED Viewed

@@ -6,8 +6,6 @@ import type { Params } from './common.js';
 import type { AstroConfig, RedirectConfig } from './config.js';
 import type { AstroGlobal } from './context.js';
 import type { AstroRenderer } from './integrations.js';
-import type { NodePool } from '../../runtime/server/render/queue/pool.js';
-import type { HTMLStringCache } from '../../runtime/server/html-string-cache.js';
 export type { SSRActions, SSRManifest, SSRManifestCSP } from '../../core/app/types.js';
 export interface NamedSSRLoadedRendererValue extends SSRLoadedRendererValue {
     name: string;
@@ -233,19 +231,6 @@ export interface SSRResult {
     directives: SSRManifestCSP['directives'];
     isStrictDynamic: SSRManifestCSP['isStrictDynamic'];
     internalFetchHeaders?: Record<string, string>;
-    /**
-     * Experimental: Configuration for queue-based rendering.
-     * - enabled: Whether to use queue-based rendering (default: true if config is object)
-     * - poolSize: Maximum number of nodes to keep in the object pool (default: 1000, 0 to disable)
-     * - cache: Whether to enable HTMLString caching (default: true)
-     */
-    _experimentalQueuedRendering?: {
-        pool?: NodePool;
-        htmlStringCache?: HTMLStringCache;
-        enabled?: boolean;
-        poolSize?: number;
-        contentCache?: boolean;
-    };
 }
 /**
  * A hint on whether the Astro runtime needs to wait on a component to render head

package/dist/vite-plugin-app/app.js CHANGED Viewed

@@ -23,7 +23,7 @@ class AstroServerApp extends BaseApp {
     this.manifestData = manifestData;
   }
   /**
-   * Loads the user's `src/app.ts` (via `virtual:astro:fetchable`) and
+   * Loads the user's `src/fetch.ts` (via `virtual:astro:fetchable`) and
    * sets it as the fetch handler. Called on every request so that HMR
    * invalidation of the virtual module is picked up automatically.
    * Vite caches the module internally so repeated calls are cheap.

package/dist/vite-plugin-app/pipeline.js CHANGED Viewed

@@ -11,9 +11,6 @@ import { isPage } from "../core/util.js";
 import { getComponentMetadata } from "../vite-plugin-astro-server/metadata.js";
 import { createResolve } from "../vite-plugin-astro-server/resolve.js";
 import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
-import { newNodePool } from "../runtime/server/render/queue/pool.js";
-import { HTMLStringCache } from "../runtime/server/html-string-cache.js";
-import { queueRenderingEnabled } from "../core/app/manifest.js";
 class RunnablePipeline extends Pipeline {
   getName() {
     return "RunnablePipeline";
@@ -58,12 +55,6 @@ class RunnablePipeline extends Pipeline {
   }) {
     const pipeline = new RunnablePipeline(loader, logger, manifest, settings, getDebugInfo);
     pipeline.routesList = manifestData;
-    if (queueRenderingEnabled(manifest.experimentalQueuedRendering)) {
-      pipeline.nodePool = newNodePool(manifest.experimentalQueuedRendering);
-      if (manifest.experimentalQueuedRendering.contentCache) {
-        pipeline.htmlStringCache = new HTMLStringCache(1e3);
-      }
-    }
     return pipeline;
   }
   async headElements(routeData) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "7.0.0-alpha.2",
+  "version": "7.0.0-beta.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",

package/dist/cli/db/index.d.ts DELETED Viewed

@@ -1,4 +0,0 @@
-import type { Arguments } from 'yargs-parser';
-export declare function db({ flags }: {
-    flags: Arguments;
-}): Promise<void>;

package/dist/cli/db/index.js DELETED Viewed

@@ -1,25 +0,0 @@
-import { resolveConfig } from "../../core/config/config.js";
-import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
-import { getPackage } from "../install-package.js";
-async function db({ flags }) {
-  const logger = createLoggerFromFlags(flags);
-  const getPackageOpts = {
-    skipAsk: !!flags.yes || !!flags.y,
-    cwd: flags.root
-  };
-  const dbPackage = await getPackage("@astrojs/db", logger, getPackageOpts, []);
-  if (!dbPackage) {
-    logger.error(
-      "check",
-      "The `@astrojs/db` package is required for this command to work. Please manually install it in your project and try again."
-    );
-    return;
-  }
-  const { cli } = dbPackage;
-  const inlineConfig = flagsToAstroInlineConfig(flags);
-  const { astroConfig } = await resolveConfig(inlineConfig, "build");
-  await cli({ flags, config: astroConfig });
-}
-export {
-  db
-};