astro 6.1.10 → 6.2.1

package/dist/core/logger/load.d.ts

@@ -0,0 +1,11 @@
+import { AstroLogger, type AstroLoggerLevel } from './core.js';
+import type { LoggerHandlerConfig } from './config.js';
+import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js';
+export declare function loadLogger(config: LoggerHandlerConfig, level?: AstroLoggerLevel): Promise<AstroLogger>;
+/**
+ * It attempts to load a logger from the entrypoint.
+ * If not provided, it creates a new logger instance on the fly.
+ * @param astroConfig
+ * @param inlineAstroConfig
+ */
+export declare function loadOrCreateNodeLogger(astroConfig: AstroConfig, inlineAstroConfig: AstroInlineConfig): Promise<AstroLogger>;

package/dist/core/logger/load.js

@@ -0,0 +1,88 @@
+import { AstroLogger } from "./core.js";
+import { AstroError } from "../errors/index.js";
+import { UnableToLoadLogger } from "../errors/errors-data.js";
+import { default as nodeLoggerCreator, createNodeLoggerFromFlags } from "./impls/node.js";
+import { default as consoleLoggerCreator } from "./impls/console.js";
+import { default as jsonLoggerCreator } from "./impls/json.js";
+import { default as composeLoggerCreator } from "./impls/compose.js";
+async function loadLogger(config, level = "info") {
+  let cause = void 0;
+  try {
+    switch (config.entrypoint) {
+      case "astro/logger/node": {
+        return new AstroLogger({
+          destination: nodeLoggerCreator(config.config),
+          level
+        });
+      }
+      case "astro/logger/console": {
+        return new AstroLogger({
+          destination: consoleLoggerCreator(config.config),
+          level
+        });
+      }
+      case "astro/logger/json": {
+        return new AstroLogger({
+          destination: jsonLoggerCreator(config.config),
+          level
+        });
+      }
+      case "astro/logger/compose": {
+        let destinations = [];
+        if (config.config?.loggers) {
+          const loggers = config.config?.loggers;
+          destinations = await Promise.all(
+            loggers.map(async (loggerConfig) => {
+              const logger = await import(
+                /* @vite-ignore */
+                loggerConfig.entrypoint
+              );
+              return logger.default(loggerConfig.config);
+            })
+          );
+        }
+        return new AstroLogger({
+          destination: composeLoggerCreator(destinations),
+          level
+        });
+      }
+      default: {
+        const nodeLogger = await import(
+          /* @vite-ignore */
+          config.entrypoint
+        );
+        return new AstroLogger({
+          destination: nodeLogger.default(config.config),
+          level
+        });
+      }
+    }
+  } catch (e) {
+    if (e instanceof Error) {
+      cause = e;
+    }
+  }
+  const error = new AstroError({
+    ...UnableToLoadLogger,
+    message: UnableToLoadLogger.message(config.entrypoint)
+  });
+  if (cause) {
+    error.cause = cause;
+  }
+  throw error;
+}
+async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
+  try {
+    if (astroConfig.experimental.logger) {
+      return await loadLogger(astroConfig.experimental.logger, inlineAstroConfig.logLevel);
+    } else {
+      return createNodeLoggerFromFlags(inlineAstroConfig);
+    }
+  } catch {
+    return createNodeLoggerFromFlags(inlineAstroConfig);
+  }
+}
+export {
+  loadLogger,
+  loadOrCreateNodeLogger
+};

package/dist/core/logger/node.d.ts

@@ -1,6 +1 @@
-import type { AstroInlineConfig } from '../../types/public/config.js';
-import { AstroLogger } from './core.js';
-import { type AstroLogMessage, type AstroLoggerDestination } from './core.js';
-export declare const nodeLogDestination: AstroLoggerDestination<AstroLogMessage>;
 export declare function enableVerboseLogging(): void;
-export declare function createNodeLogger(inlineConfig: AstroInlineConfig): AstroLogger;

package/dist/core/logger/node.js

@@ -1,33 +1,4 @@
 import { createDebug, enable as obugEnable } from "obug";
-import { AstroLogger } from "./core.js";
-import {
-  getEventPrefix,
-  levels
-} from "./core.js";
-const nodeLogDestination = {
-  write(event) {
-    let dest = process.stderr;
-    if (levels[event.level] < levels["error"]) {
-      dest = process.stdout;
-    }
-    let format = event._format ?? "default";
-    let trailingLine = event.newLine ? "\n" : "";
-    switch (format) {
-      case "json": {
-        dest.write(JSON.stringify({ message: event.message, label: event.label }) + trailingLine);
-        return true;
-      }
-      case "default": {
-        if (event.label === "SKIP_FORMAT") {
-          dest.write(event.message + trailingLine);
-        } else {
-          dest.write(getEventPrefix(event) + " " + event.message + trailingLine);
-        }
-        return true;
-      }
-    }
-  }
-};
 const debuggers = {};
 function debug(type, ...messages) {
   const namespace = `astro:${type}`;
@@ -43,15 +14,6 @@ function enableVerboseLogging() {
     'Tip: Set the DEBUG env variable directly for more control. Example: "DEBUG=astro:*,vite:* astro build".'
   );
 }
-function createNodeLogger(inlineConfig) {
-  if (inlineConfig.logger) return inlineConfig.logger;
-  return new AstroLogger({
-    destination: nodeLogDestination,
-    level: inlineConfig.logLevel ?? "info"
-  });
-}
 export {
-  createNodeLogger,
-  enableVerboseLogging,
-  nodeLogDestination
+  enableVerboseLogging
 };

package/dist/core/logger/public.d.ts

@@ -0,0 +1,17 @@
+import { type AstroLoggerLevel } from './core.js';
+/**
+ * Returns `true` if `messageLevel` has a level equals or higher than `configuredLevel`. As a golden rule,
+ * the first argument should be level of the incoming message, and the second argument should be the
+ * configured level of the logger.
+ *
+ * @param messageLevel The level of the incoming message
+ * @param configuredLevel The level the logger is configured with
+ *
+ * @example
+ *
+ * ```js
+ * matchesLevel('error', 'info') // true, because 'error' has higher priority than 'info'
+ * matchesLevel('info', 'error') // false, because 'info' has lower priority than 'error'
+ * ```
+ */
+export declare function matchesLevel(messageLevel: AstroLoggerLevel, configuredLevel: AstroLoggerLevel): boolean;

package/dist/core/logger/public.js

@@ -0,0 +1,7 @@
+import { levels } from "./core.js";
+function matchesLevel(messageLevel, configuredLevel) {
+  return levels[messageLevel] >= levels[configuredLevel];
+}
+export {
+  matchesLevel
+};

package/dist/core/messages/runtime.js

@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.1.10"}`
+        `v${"6.2.1"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/index.js

@@ -74,7 +74,8 @@ function createContext({
     },
     session: void 0,
     cache: new DisabledAstroCache(),
-    csp: void 0
+    csp: void 0,
+    logger: void 0
   };
   return Object.assign(context, {
     getActionResult: createGetActionResult(context.locals),

package/dist/core/preview/index.js

@@ -1,12 +1,12 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { AstroIntegrationLogger } from "../../core/logger/core.js";
+import { AstroIntegrationLogger } from "../logger/core.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
 import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
 import { resolveConfig } from "../config/config.js";
-import { createNodeLogger } from "../logger/node.js";
+import { loadOrCreateNodeLogger } from "../logger/load.js";
 import { createSettings } from "../config/settings.js";
 import { createRoutesList } from "../routing/create-manifest.js";
 import { getPrerenderDefault } from "../../prerender/utils.js";
@@ -15,8 +15,8 @@ import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
 async function preview(inlineConfig) {
   ensureProcessNodeEnv("production");
-  const logger = createNodeLogger(inlineConfig);
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "preview");
+  const logger = await loadOrCreateNodeLogger(astroConfig, inlineConfig ?? {});
   telemetry.record(eventCliSession("preview", userConfig));
   const _settings = await createSettings(
     astroConfig,
@@ -67,6 +67,7 @@ async function preview(inlineConfig) {
     base: settings.config.base,
     logger: new AstroIntegrationLogger(logger.options, settings.adapter.name),
     headers: settings.config.server.headers,
+    allowedHosts: settings.config.server.allowedHosts,
     root: settings.config.root
   });
   return server;

package/dist/core/render-context.js

@@ -467,6 +467,26 @@ class RenderContext {
             renderContext.result?.scriptHashes.push(hash);
           }
         };
+      },
+      get logger() {
+        if (!pipeline.manifest.experimentalLogger) {
+          pipeline.logger.warn(
+            null,
+            "The Astro.logger is available only when experimental.logger is defined."
+          );
+          return void 0;
+        }
+        return {
+          info(msg) {
+            pipeline.logger.info(null, msg);
+          },
+          warn(msg) {
+            pipeline.logger.warn(null, msg);
+          },
+          error(msg) {
+            pipeline.logger.error(null, msg);
+          }
+        };
       }
     };
   }
@@ -544,7 +564,8 @@ class RenderContext {
         extraHead: [],
         extraStyleHashes,
         extraScriptHashes,
-        propagators: /* @__PURE__ */ new Set()
+        propagators: /* @__PURE__ */ new Set(),
+        templateDepth: 0
       },
       cspDestination: manifest.csp?.cspDestination ?? (routeData.prerender ? "meta" : "header"),
       shouldInjectCspMetaTags,
@@ -698,6 +719,19 @@ class RenderContext {
             renderContext.result?.scriptHashes.push(hash);
           }
         };
+      },
+      get logger() {
+        return {
+          info(msg) {
+            pipeline.logger.info(null, msg);
+          },
+          warn(msg) {
+            pipeline.logger.warn(null, msg);
+          },
+          error(msg) {
+            pipeline.logger.error(null, msg);
+          }
+        };
       }
     };
   }

package/dist/core/sync/index.js

@@ -17,7 +17,7 @@ import { eventCliSession } from "../../events/session.js";
 import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
 import { getTimeStat } from "../build/util.js";
 import { resolveConfig } from "../config/config.js";
-import { createNodeLogger } from "../logger/node.js";
+import { loadOrCreateNodeLogger } from "../logger/load.js";
 import { createSettings } from "../config/settings.js";
 import { createVite } from "../create-vite.js";
 import {
@@ -32,8 +32,8 @@ import { ensureProcessNodeEnv } from "../util.js";
 import { normalizePath } from "../viteUtils.js";
 async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
   ensureProcessNodeEnv("production");
-  const logger = createNodeLogger(inlineConfig);
   const { astroConfig, userConfig } = await resolveConfig(inlineConfig ?? {}, "sync");
+  const logger = await loadOrCreateNodeLogger(astroConfig, inlineConfig ?? {});
   if (_telemetry) {
     telemetry.record(eventCliSession("sync", userConfig));
   }

package/dist/core/wait-until.d.ts

@@ -0,0 +1 @@
+export type WaitUntilHook = (this: void, promise: Promise<unknown>) => void;

package/dist/manifest/serialized.js

@@ -142,6 +142,10 @@ async function createSerializedManifest(settings, encodedKey) {
       isStrictDynamic: getStrictDynamic(settings.config.security.csp)
     };
   }
+  let experimentalLogger = void 0;
+  if (settings.config.experimental.logger) {
+    experimentalLogger = settings.config.experimental.logger;
+  }
   return {
     rootDir: settings.config.root.toString(),
     srcDir: settings.config.srcDir.toString(),
@@ -195,7 +199,8 @@ async function createSerializedManifest(settings, encodedKey) {
     },
     logLevel: settings.logLevel,
     shouldInjectCspMetaTags: false,
-    experimentalQueuedRendering: settings.config.experimental?.queuedRendering
+    experimentalQueuedRendering: settings.config.experimental?.queuedRendering,
+    experimentalLogger
   };
 }
 export {

package/dist/runtime/compiler/index.d.ts

@@ -1 +1 @@
-export { addAttribute, createAstro, createComponent, createTransitionScope, defineScriptVars, defineStyleVars, Fragment, maybeRenderHead, mergeSlots, render, renderComponent, renderHead, renderScript, renderSlot, renderTransition, spreadAttributes, unescapeHTML, } from '../server/index.js';
+export { addAttribute, createAstro, createComponent, createTransitionScope, defineScriptVars, defineStyleVars, Fragment, maybeRenderHead, mergeSlots, render, renderComponent, renderHead, renderScript, renderSlot, renderTransition, templateEnter, templateExit, spreadAttributes, unescapeHTML, } from '../server/index.js';

package/dist/runtime/compiler/index.js

@@ -14,6 +14,8 @@ import {
   renderScript,
   renderSlot,
   renderTransition,
+  templateEnter,
+  templateExit,
   spreadAttributes,
   unescapeHTML
 } from "../server/index.js";
@@ -34,5 +36,7 @@ export {
   renderSlot,
   renderTransition,
   spreadAttributes,
+  templateEnter,
+  templateExit,
   unescapeHTML
 };

package/dist/runtime/server/astro-global.js

@@ -90,6 +90,9 @@ function createAstro(site) {
     },
     get cache() {
       throw createError("cache");
+    },
+    get logger() {
+      throw createError("logger");
     }
   };
 }

package/dist/runtime/server/index.d.ts

@@ -6,6 +6,7 @@ export { renderJSX } from './jsx.js';
 export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
 export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, Renderer as Renderer, renderComponent, renderHead, renderHTMLElement, renderPage, renderScript, renderScriptElement, renderSlot, renderSlotToString, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, voidElementNames, } from './render/index.js';
 export type { ServerIslandComponent } from './render/server-islands.js';
+export { templateEnter, templateExit } from './render/template-depth.js';
 export { createTransitionScope, renderTransition } from './transition.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;
 export declare function spreadAttributes(values?: Record<any, any>, _name?: string, { class: scopedClassName }?: {

package/dist/runtime/server/index.js

@@ -31,6 +31,7 @@ import {
   renderUniqueStylesheet,
   voidElementNames
 } from "./render/index.js";
+import { templateEnter, templateExit } from "./render/template-depth.js";
 import { createTransitionScope, renderTransition } from "./transition.js";
 import { markHTMLString as markHTMLString2 } from "./escape.js";
 import { addAttribute as addAttribute2, Renderer as Renderer2 } from "./render/index.js";
@@ -117,6 +118,8 @@ export {
   renderTransition,
   renderUniqueStylesheet,
   spreadAttributes,
+  templateEnter,
+  templateExit,
   unescapeHTML,
   voidElementNames
 };

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

@@ -61,12 +61,28 @@ function stringifyChunk(result, chunk) {
       }
       case "script": {
         const { id, content } = instruction;
+        if (result._metadata.templateDepth > 0) {
+          return content;
+        }
         if (result._metadata.renderedScripts.has(id)) {
           return "";
         }
         result._metadata.renderedScripts.add(id);
         return content;
       }
+      case "template-enter": {
+        result._metadata.templateDepth++;
+        return "";
+      }
+      case "template-exit": {
+        if (result._metadata.templateDepth <= 0) {
+          throw new Error(
+            "Unexpected template-exit instruction without a matching template-enter. This may indicate that the compiler emitted unbalanced template boundaries, or that a component manually injected a template-exit render instruction."
+          );
+        }
+        result._metadata.templateDepth--;
+        return "";
+      }
       default: {
         throw new Error(`Unknown chunk type: ${chunk.type}`);
       }

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

@@ -26,6 +26,12 @@ export type RenderScriptInstruction = {
     id: string;
     content: string;
 };
-export type RenderInstruction = RenderDirectiveInstruction | RenderHeadInstruction | MaybeRenderHeadInstruction | RendererHydrationScriptInstruction | ServerIslandRuntimeInstruction | RenderScriptInstruction;
+export type TemplateEnterInstruction = {
+    type: 'template-enter';
+};
+export type TemplateExitInstruction = {
+    type: 'template-exit';
+};
+export type RenderInstruction = RenderDirectiveInstruction | RenderHeadInstruction | MaybeRenderHeadInstruction | RendererHydrationScriptInstruction | ServerIslandRuntimeInstruction | RenderScriptInstruction | TemplateEnterInstruction | TemplateExitInstruction;
 export declare function createRenderInstruction<T extends RenderInstruction>(instruction: T): T;
 export declare function isRenderInstruction(chunk: any): chunk is RenderInstruction;

package/dist/runtime/server/render/template-depth.d.ts

@@ -0,0 +1,13 @@
+import type { SSRResult } from '../../../types/public/internal.js';
+/**
+ * Emitted by the compiler when entering an HTML `<template>` element.
+ */
+export declare function templateEnter(_result: SSRResult): {
+    type: "template-enter";
+};
+/**
+ * Emitted by the compiler when exiting an HTML `<template>` element.
+ */
+export declare function templateExit(_result: SSRResult): {
+    type: "template-exit";
+};

package/dist/runtime/server/render/template-depth.js

@@ -0,0 +1,11 @@
+import { createRenderInstruction } from "./instruction.js";
+function templateEnter(_result) {
+  return createRenderInstruction({ type: "template-enter" });
+}
+function templateExit(_result) {
+  return createRenderInstruction({ type: "template-exit" });
+}
+export {
+  templateEnter,
+  templateExit
+};

package/dist/types/astro.d.ts

@@ -1,3 +1,4 @@
+import type { Server } from 'node:http';
 import type { AstroTimer } from '../core/config/timer.js';
 import type { TSConfig } from '../core/config/tsconfig.js';
 import type { AstroLogger, AstroLoggerLevel } from '../core/logger/core.js';
@@ -66,6 +67,7 @@ export interface AstroSettings {
         styleHashes: Required<CspObject['styleDirective']>['hashes'];
     };
     logLevel: AstroLoggerLevel;
+    fontsHttpServer: Server | null;
 }
 /** Generic interface for a component (Astro, Svelte, React, etc.) */
 export interface ComponentInstance {

package/dist/types/public/common.d.ts

@@ -137,3 +137,4 @@ export type InferGetStaticPropsType<T> = T extends (opts: GetStaticPathsOptions)
 export type Params = Record<string, string | undefined>;
 export type Props = Record<string, unknown>;
 export type CodeLanguage = BundledLanguage | LanguageRegistration | SpecialLanguage;
+export type { AstroLoggerDestination, AstroLoggerLevel, AstroLoggerMessage, } from '../../core/logger/core.js';