astro 6.1.10 → 6.2.0

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

@@ -1,12 +1,19 @@
-export interface AstroLoggerDestination<T> {
-    write: (chunk: T) => boolean;
+export interface AstroLoggerDestination<T = unknown> {
+    /**
+     * It receives a message and writes it into a destination
+     */
+    write: (chunk: T) => void;
+    /**
+     * It dumps logs without closing the connection to the destination.
+     * Method that can be used by specialized loggers.
+     */
+    flush?: () => Promise<void> | void;
+    /**
+     * It dumps logs and closes the connection to the destination.
+     * Method that can be used by specialized loggers.
+     */
+    close?: () => Promise<void> | void;
 }
-/**
- * How the log should be formatted
- * - 'default': how Astro usually format the logs
- * - 'json': logs are formatted in JSON format
- */
-export type AstroLoggerFormat = 'default' | 'json';
 /**
  * The level of logging. Priority is the following:
  * 1. debug
@@ -21,15 +28,19 @@ export type AstroLoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
  * rather than specific to a single command, function, use, etc. The label will be
  * shown in the log message to the user, so it should be relevant.
  */
-type AstroLoggerLabel = 'add' | 'build' | 'check' | 'config' | 'content' | 'crypto' | 'deprecated' | 'markdown' | 'router' | 'types' | 'vite' | 'watch' | 'middleware' | 'preferences' | 'redirects' | 'sync' | 'session' | 'toolbar' | 'assets' | 'env' | 'update' | 'adapter' | 'islands' | 'cache' | 'csp' | 'SKIP_FORMAT';
+declare const AstroLoggerLabels: readonly ["add", "build", "check", "config", "content", "crypto", "deprecated", "markdown", "router", "types", "vite", "watch", "middleware", "preferences", "redirects", "sync", "session", "toolbar", "assets", "env", "update", "adapter", "islands", "cache", "csp", "SKIP_FORMAT"];
+type AstroLoggerLabel = (typeof AstroLoggerLabels)[number];
 export interface AstroLogOptions {
-    destination: AstroLoggerDestination<AstroLogMessage>;
+    destination: AstroLoggerDestination<AstroLoggerMessage>;
     level: AstroLoggerLevel;
-    _format?: AstroLoggerFormat;
+    /**
+     * Optional configuration for the logger destination
+     */
+    config?: Record<string, any> | undefined;
 }
 /** @lintignore */
 export declare const dateTimeFormat: Intl.DateTimeFormat;
-export interface AstroLogMessage {
+export interface AstroLoggerMessage {
     /**
      * Label associated to the message. Used by Astro for pretty logging
      */
@@ -55,7 +66,7 @@ export declare function debug(...args: any[]): void;
  * This includes the timestamp, log level, and label all properly formatted
  * with colors. This is shared across different loggers, so it's defined here.
  */
-export declare function getEventPrefix({ level, label }: AstroLogMessage): string;
+export declare function getEventPrefix({ level, label }: AstroLoggerMessage): string;
 /** Print out a timer message for debug() */
 export declare function timerMessage(message: string, startTime?: number): string;
 export declare class AstroLogger {
@@ -67,6 +78,15 @@ export declare class AstroLogger {
     debug(label: AstroLoggerLabel, ...messages: any[]): void;
     level(): AstroLoggerLevel;
     forkIntegrationLogger(label: string): AstroIntegrationLogger;
+    setDestination(destination: AstroLoggerDestination<AstroLoggerMessage>): void;
+    /**
+     * It calls the `close` function of the provided destination, if it exists.
+     */
+    close(): void;
+    /**
+     * It calls the `flush` function of the provided destinatin, if it exists.
+     */
+    flush(): void;
 }
 export declare class AstroIntegrationLogger {
     options: AstroLogOptions;

package/dist/core/logger/core.js

@@ -1,4 +1,34 @@
 import colors from "piccolore";
+const AstroLoggerLabels = [
+  "add",
+  "build",
+  "check",
+  "config",
+  "content",
+  "crypto",
+  "deprecated",
+  "markdown",
+  "router",
+  "types",
+  "vite",
+  "watch",
+  "middleware",
+  "preferences",
+  "redirects",
+  "sync",
+  "session",
+  "toolbar",
+  "assets",
+  "env",
+  "update",
+  "adapter",
+  "islands",
+  "cache",
+  "csp",
+  // SKIP_FORMAT: A special label that tells the logger not to apply any formatting.
+  // Useful for messages that are already formatted, like the server start message.
+  "SKIP_FORMAT"
+];
 const dateTimeFormat = new Intl.DateTimeFormat([], {
   hour: "2-digit",
   minute: "2-digit",
@@ -19,8 +49,7 @@ function log(opts, level, label, message, newLine = true) {
     label,
     level,
     message,
-    newLine,
-    _format: opts._format
+    newLine
   };
   if (!isLogLevelEnabled(logLevel, level)) {
     return;
@@ -75,9 +104,6 @@ function timerMessage(message, startTime = Date.now()) {
 class AstroLogger {
   options;
   constructor(options) {
-    if (!options._format) {
-      options._format = "default";
-    }
     this.options = options;
   }
   info(label, message, newLine = true) {
@@ -98,6 +124,25 @@ class AstroLogger {
   forkIntegrationLogger(label) {
     return new AstroIntegrationLogger(this.options, label);
   }
+  setDestination(destination) {
+    this.options.destination = destination;
+  }
+  /**
+   * It calls the `close` function of the provided destination, if it exists.
+   */
+  close() {
+    if (this.options.destination.close) {
+      this.options.destination.close();
+    }
+  }
+  /**
+   * It calls the `flush` function of the provided destinatin, if it exists.
+   */
+  flush() {
+    if (this.options.destination.flush) {
+      this.options.destination.flush();
+    }
+  }
 }
 class AstroIntegrationLogger {
   options;

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

@@ -0,0 +1,60 @@
+import type { LoggerHandlerConfig } from './config.js';
+import type { JsonHandlerConfig } from './impls/json.js';
+import type { NodeHandlerConfig } from './impls/node.js';
+import type { ConsoleHandlerConfig } from './impls/console.js';
+export declare const logHandlers: {
+    /**
+     * It uses the built-in Astro JSON logger.
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.json({ pretty: true })
+     *   }
+     * })
+     * ```
+     */
+    json(config?: JsonHandlerConfig): LoggerHandlerConfig;
+    /**
+     * It uses the built-in Astro Node.js logger.
+     *
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.node({ pretty: true })
+     *   }
+     * })
+     * ```
+     */
+    node(config?: NodeHandlerConfig): LoggerHandlerConfig;
+    /**
+     * It uses the built-in Astro console logger.
+     *
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.console({ pretty: true })
+     *   }
+     * })
+     * ```
+     */
+    console(config?: ConsoleHandlerConfig): LoggerHandlerConfig;
+    /**
+     * It allows composing different loggers
+     *
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.compose(
+     *       logHandlers.console(),
+     *       logHandlers.json(),
+     *     )
+     *   }
+     * })
+     * ```
+     */
+    compose(...loggers: LoggerHandlerConfig[]): LoggerHandlerConfig;
+};

package/dist/core/logger/handlers.js

@@ -0,0 +1,81 @@
+const logHandlers = {
+  /**
+   * It uses the built-in Astro JSON logger.
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.json({ pretty: true })
+   *   }
+   * })
+   * ```
+   */
+  json(config) {
+    return {
+      entrypoint: "astro/logger/json",
+      config
+    };
+  },
+  /**
+   * It uses the built-in Astro Node.js logger.
+   *
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.node({ pretty: true })
+   *   }
+   * })
+   * ```
+   */
+  node(config) {
+    return {
+      entrypoint: "astro/logger/node",
+      config
+    };
+  },
+  /**
+   * It uses the built-in Astro console logger.
+   *
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.console({ pretty: true })
+   *   }
+   * })
+   * ```
+   */
+  console(config) {
+    return {
+      entrypoint: "astro/logger/console",
+      config
+    };
+  },
+  /**
+   * It allows composing different loggers
+   *
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.compose(
+   *       logHandlers.console(),
+   *       logHandlers.json(),
+   *     )
+   *   }
+   * })
+   * ```
+   */
+  compose(...loggers) {
+    return {
+      entrypoint: "astro/logger/compose",
+      config: {
+        loggers
+      }
+    };
+  }
+};
+export {
+  logHandlers
+};

package/dist/core/logger/impls/compose.d.ts

@@ -0,0 +1,2 @@
+import type { AstroLoggerDestination } from '../core.js';
+export default function compose(destinations: AstroLoggerDestination[]): AstroLoggerDestination;

package/dist/core/logger/impls/compose.js

@@ -0,0 +1,26 @@
+function compose(destinations) {
+  return {
+    write(chunk) {
+      for (const logger of destinations) {
+        logger.write(chunk);
+      }
+    },
+    flush() {
+      for (const logger of destinations) {
+        if (logger.flush) {
+          logger.flush();
+        }
+      }
+    },
+    close() {
+      for (const logger of destinations) {
+        if (logger.close) {
+          logger.close();
+        }
+      }
+    }
+  };
+}
+export {
+  compose as default
+};

package/dist/core/logger/impls/console.d.ts

@@ -0,0 +1,9 @@
+import { type AstroLoggerMessage, type AstroLoggerDestination, type AstroLoggerLevel, AstroLogger } from '../core.js';
+import type { NodeHandlerConfig } from './node.js';
+export type ConsoleHandlerConfig = {
+    level?: AstroLoggerLevel;
+};
+export declare function createConsoleLogger({ level }: {
+    level: AstroLoggerLevel;
+}): AstroLogger;
+export default function (options?: NodeHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;

package/dist/core/logger/impls/console.js

@@ -0,0 +1,38 @@
+import {
+  getEventPrefix,
+  levels,
+  AstroLogger
+} from "../core.js";
+import { matchesLevel } from "../public.js";
+function consoleLogDestination(config = {}) {
+  const { level = "info" } = config;
+  return {
+    write(event) {
+      let dest = console.error;
+      if (levels[event.level] < levels["error"]) {
+        dest = console.info;
+      }
+      if (!matchesLevel(event.level, level)) {
+        return;
+      }
+      if (event.label === "SKIP_FORMAT") {
+        dest(event.message);
+      } else {
+        dest(getEventPrefix(event) + " " + event.message);
+      }
+    }
+  };
+}
+function createConsoleLogger({ level }) {
+  return new AstroLogger({
+    level,
+    destination: consoleLogDestination()
+  });
+}
+function console_default(options) {
+  return consoleLogDestination(options);
+}
+export {
+  createConsoleLogger,
+  console_default as default
+};

package/dist/core/logger/impls/json.d.ts

@@ -0,0 +1,15 @@
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import type { AstroInlineConfig } from '../../../types/public/index.js';
+export type JsonHandlerConfig = {
+    /**
+     * Whether the JSON line should format on multiple lines
+     */
+    pretty?: boolean;
+    /**
+     * The level of logs that should be printed by the logger.
+     */
+    level?: AstroLoggerLevel;
+};
+export declare const SGR_REGEX: RegExp;
+export default function jsonLoggerDestination(config?: JsonHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export declare function createJsonLoggerFromFlags(config: AstroInlineConfig): AstroLogger;

package/dist/core/logger/impls/json.js

@@ -0,0 +1,42 @@
+import {
+  AstroLogger,
+  levels
+} from "../core.js";
+import { matchesLevel } from "../public.js";
+const SGR_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function jsonLoggerDestination(config = {}) {
+  const { pretty = false, level = "info" } = config;
+  return {
+    write(event) {
+      let dest = process.stderr;
+      if (levels[event.level] < levels["error"]) {
+        dest = process.stdout;
+      }
+      if (!matchesLevel(event.level, level)) {
+        return;
+      }
+      let trailingLine = event.newLine ? "\n" : "";
+      const message = event.message.replace(SGR_REGEX, "");
+      if (pretty) {
+        dest.write(
+          JSON.stringify({ message, label: event.label, level: event.level }, null, 2) + trailingLine
+        );
+      } else {
+        dest.write(
+          JSON.stringify({ message, label: event.label, level: event.level }) + trailingLine
+        );
+      }
+    }
+  };
+}
+function createJsonLoggerFromFlags(config) {
+  return new AstroLogger({
+    destination: jsonLoggerDestination({ pretty: false }),
+    level: config.logLevel ?? "info"
+  });
+}
+export {
+  SGR_REGEX,
+  createJsonLoggerFromFlags,
+  jsonLoggerDestination as default
+};

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

@@ -0,0 +1,7 @@
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import type { AstroInlineConfig } from '../../../types/public/index.js';
+export type NodeHandlerConfig = {
+    level?: AstroLoggerLevel;
+};
+export default function (options?: NodeHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export declare function createNodeLoggerFromFlags(inlineConfig: AstroInlineConfig): AstroLogger;

package/dist/core/logger/impls/node.js

@@ -0,0 +1,40 @@
+import {
+  AstroLogger,
+  getEventPrefix,
+  levels
+} from "../core.js";
+import { matchesLevel } from "../public.js";
+function nodeLogDestination(config = {}) {
+  const { level = "info" } = config;
+  return {
+    write(event) {
+      let dest = process.stderr;
+      if (levels[event.level] < levels["error"]) {
+        dest = process.stdout;
+      }
+      if (!matchesLevel(event.level, level)) {
+        return;
+      }
+      let trailingLine = event.newLine ? "\n" : "";
+      if (event.label === "SKIP_FORMAT") {
+        dest.write(event.message + trailingLine);
+      } else {
+        dest.write(getEventPrefix(event) + " " + event.message + trailingLine);
+      }
+    }
+  };
+}
+function node_default(options) {
+  return nodeLogDestination(options);
+}
+function createNodeLoggerFromFlags(inlineConfig) {
+  if (inlineConfig.logger) return inlineConfig.logger;
+  return new AstroLogger({
+    destination: nodeLogDestination(),
+    level: inlineConfig.logLevel ?? "info"
+  });
+}
+export {
+  createNodeLoggerFromFlags,
+  node_default as default
+};

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.0"}`
       )} ${headline}`
     );
   }