astro 5.16.1 → 5.16.2

package/dist/cli/info/infra/dev-debug-info-provider.d.ts

@@ -1,15 +1,18 @@
 import type { AstroConfig } from '../../../types/public/index.js';
 import type { AstroVersionProvider, OperatingSystemProvider } from '../../definitions.js';
 import type { DebugInfoProvider, NodeVersionProvider, PackageManager } from '../definitions.js';
-interface Options {
-    config: Pick<AstroConfig, 'output' | 'adapter' | 'integrations'>;
-    astroVersionProvider: AstroVersionProvider;
-    packageManager: PackageManager;
-    operatingSystemProvider: OperatingSystemProvider;
-    nodeVersionProvider: NodeVersionProvider;
-}
+import type { DebugInfo } from '../domain/debug-info.js';
 /**
  * Returns debug info without any package versions, to avoid slowing down the dev server
  */
-export declare function createDevDebugInfoProvider({ config, astroVersionProvider, packageManager, operatingSystemProvider, nodeVersionProvider, }: Options): DebugInfoProvider;
-export {};
+export declare class DevDebugInfoProvider implements DebugInfoProvider {
+    #private;
+    constructor({ config, astroVersionProvider, packageManager, operatingSystemProvider, nodeVersionProvider, }: {
+        config: Pick<AstroConfig, 'output' | 'adapter' | 'integrations'>;
+        astroVersionProvider: AstroVersionProvider;
+        packageManager: PackageManager;
+        operatingSystemProvider: OperatingSystemProvider;
+        nodeVersionProvider: NodeVersionProvider;
+    });
+    get(): Promise<DebugInfo>;
+}

package/dist/cli/info/infra/dev-debug-info-provider.js

@@ -1,26 +1,36 @@
-function createDevDebugInfoProvider({
-  config,
-  astroVersionProvider,
-  packageManager,
-  operatingSystemProvider,
-  nodeVersionProvider
-}) {
-  return {
-    async get() {
-      const debugInfo = [
-        ["Astro", `v${astroVersionProvider.version}`],
-        ["Node", nodeVersionProvider.get()],
-        ["System", operatingSystemProvider.displayName],
-        ["Package Manager", packageManager.getName()],
-        ["Output", config.output],
-        ["Adapter", config.adapter?.name ?? "none"]
-      ];
-      const integrations = config.integrations.map((integration) => integration.name);
-      debugInfo.push(["Integrations", integrations.length > 0 ? integrations : "none"]);
-      return debugInfo;
-    }
-  };
+class DevDebugInfoProvider {
+  #config;
+  #astroVersionProvider;
+  #packageManager;
+  #operatingSystemProvider;
+  #nodeVersionProvider;
+  constructor({
+    config,
+    astroVersionProvider,
+    packageManager,
+    operatingSystemProvider,
+    nodeVersionProvider
+  }) {
+    this.#config = config;
+    this.#astroVersionProvider = astroVersionProvider;
+    this.#packageManager = packageManager;
+    this.#operatingSystemProvider = operatingSystemProvider;
+    this.#nodeVersionProvider = nodeVersionProvider;
+  }
+  async get() {
+    const debugInfo = [
+      ["Astro", `v${this.#astroVersionProvider.version}`],
+      ["Node", this.#nodeVersionProvider.version],
+      ["System", this.#operatingSystemProvider.displayName],
+      ["Package Manager", this.#packageManager.name],
+      ["Output", this.#config.output],
+      ["Adapter", this.#config.adapter?.name ?? "none"]
+    ];
+    const integrations = this.#config.integrations.map((integration) => integration.name);
+    debugInfo.push(["Integrations", integrations.length > 0 ? integrations : "none"]);
+    return debugInfo;
+  }
 }
 export {
-  createDevDebugInfoProvider
+  DevDebugInfoProvider
 };

package/dist/cli/info/infra/noop-package-manager.d.ts

@@ -1,2 +1,5 @@
 import type { PackageManager } from '../definitions.js';
-export declare function createNoopPackageManager(): PackageManager;
+export declare class NoopPackageManager implements PackageManager {
+    readonly name: string;
+    getPackageVersion(): Promise<string | undefined>;
+}

package/dist/cli/info/infra/noop-package-manager.js

@@ -1,13 +1,9 @@
-function createNoopPackageManager() {
-  return {
-    getName() {
-      return "unknown";
-    },
-    async getPackageVersion() {
-      return void 0;
-    }
-  };
+class NoopPackageManager {
+  name = "unknown";
+  async getPackageVersion() {
+    return void 0;
+  }
 }
 export {
-  createNoopPackageManager
+  NoopPackageManager
 };

package/dist/cli/info/infra/npm-package-manager.d.ts

@@ -1,7 +1,10 @@
 import type { CommandExecutor } from '../../definitions.js';
 import type { PackageManager } from '../definitions.js';
-interface Options {
-    commandExecutor: CommandExecutor;
+export declare class NpmPackageManager implements PackageManager {
+    #private;
+    readonly name: string;
+    constructor({ commandExecutor }: {
+        commandExecutor: CommandExecutor;
+    });
+    getPackageVersion(name: string): Promise<string | undefined>;
 }
-export declare function createNpmPackageManager({ commandExecutor }: Options): PackageManager;
-export {};

package/dist/cli/info/infra/npm-package-manager.js

@@ -1,32 +1,32 @@
-function createNpmPackageManager({ commandExecutor }) {
-  return {
-    getName() {
-      return "npm";
-    },
-    async getPackageVersion(name) {
-      try {
-        const { stdout } = await commandExecutor.execute(
-          "npm",
-          ["ls", name, "--json", "--depth=1"],
-          {
-            shell: true
-          }
-        );
-        const parsedNpmOutput = JSON.parse(stdout);
-        if (!parsedNpmOutput.dependencies) {
-          return void 0;
+class NpmPackageManager {
+  name = "npm";
+  #commandExecutor;
+  constructor({ commandExecutor }) {
+    this.#commandExecutor = commandExecutor;
+  }
+  async getPackageVersion(name) {
+    try {
+      const { stdout } = await this.#commandExecutor.execute(
+        "npm",
+        ["ls", name, "--json", "--depth=1"],
+        {
+          shell: true
         }
-        if (parsedNpmOutput.dependencies[name]) {
-          return `v${parsedNpmOutput.dependencies[name].version}`;
-        }
-        const astro = parsedNpmOutput.dependencies.astro;
-        return astro ? `v${astro.dependencies[name].version}` : void 0;
-      } catch {
+      );
+      const parsedNpmOutput = JSON.parse(stdout);
+      if (!parsedNpmOutput.dependencies) {
         return void 0;
       }
+      if (parsedNpmOutput.dependencies[name]) {
+        return `v${parsedNpmOutput.dependencies[name].version}`;
+      }
+      const astro = parsedNpmOutput.dependencies.astro;
+      return astro ? `v${astro.dependencies[name].version}` : void 0;
+    } catch {
+      return void 0;
     }
-  };
+  }
 }
 export {
-  createNpmPackageManager
+  NpmPackageManager
 };

package/dist/cli/info/infra/pnpm-package-manager.d.ts

@@ -1,7 +1,10 @@
 import type { CommandExecutor } from '../../definitions.js';
 import type { PackageManager } from '../definitions.js';
-interface Options {
-    commandExecutor: CommandExecutor;
+export declare class PnpmPackageManager implements PackageManager {
+    #private;
+    readonly name: string;
+    constructor({ commandExecutor }: {
+        commandExecutor: CommandExecutor;
+    });
+    getPackageVersion(name: string): Promise<string | undefined>;
 }
-export declare function createPnpmPackageManager({ commandExecutor }: Options): PackageManager;
-export {};

package/dist/cli/info/infra/pnpm-package-manager.js

@@ -1,33 +1,33 @@
 function formatPnpmVersionOutput(versionOutput) {
   return versionOutput.startsWith("link:") ? "Local" : `v${versionOutput}`;
 }
-function createPnpmPackageManager({ commandExecutor }) {
-  return {
-    getName() {
-      return "pnpm";
-    },
-    async getPackageVersion(name) {
-      try {
-        const { stdout } = await commandExecutor.execute("pnpm", ["why", name, "--json"], {
-          shell: true
-        });
-        const parsedOutput = JSON.parse(stdout);
-        const deps = parsedOutput[0].dependencies;
-        if (parsedOutput.length === 0 || !deps) {
-          return void 0;
-        }
-        const userProvidedDependency = deps[name];
-        if (userProvidedDependency) {
-          return formatPnpmVersionOutput(userProvidedDependency.version);
-        }
-        const astroDependency = deps.astro?.dependencies[name];
-        return astroDependency ? formatPnpmVersionOutput(astroDependency.version) : void 0;
-      } catch {
+class PnpmPackageManager {
+  name = "pnpm";
+  #commandExecutor;
+  constructor({ commandExecutor }) {
+    this.#commandExecutor = commandExecutor;
+  }
+  async getPackageVersion(name) {
+    try {
+      const { stdout } = await this.#commandExecutor.execute("pnpm", ["why", name, "--json"], {
+        shell: true
+      });
+      const parsedOutput = JSON.parse(stdout);
+      const deps = parsedOutput[0].dependencies;
+      if (parsedOutput.length === 0 || !deps) {
         return void 0;
       }
+      const userProvidedDependency = deps[name];
+      if (userProvidedDependency) {
+        return formatPnpmVersionOutput(userProvidedDependency.version);
+      }
+      const astroDependency = deps.astro?.dependencies[name];
+      return astroDependency ? formatPnpmVersionOutput(astroDependency.version) : void 0;
+    } catch {
+      return void 0;
     }
-  };
+  }
 }
 export {
-  createPnpmPackageManager
+  PnpmPackageManager
 };

package/dist/cli/info/infra/process-node-version-provider.d.ts

@@ -1,2 +1,4 @@
 import type { NodeVersionProvider } from '../definitions.js';
-export declare function createProcessNodeVersionProvider(): NodeVersionProvider;
+export declare class ProcessNodeVersionProvider implements NodeVersionProvider {
+    readonly version: string;
+}

package/dist/cli/info/infra/process-node-version-provider.js

@@ -1,10 +1,6 @@
-function createProcessNodeVersionProvider() {
-  return {
-    get() {
-      return process.version;
-    }
-  };
+class ProcessNodeVersionProvider {
+  version = process.version;
 }
 export {
-  createProcessNodeVersionProvider
+  ProcessNodeVersionProvider
 };

package/dist/cli/info/infra/process-package-manager-user-agent-provider.d.ts

@@ -1,2 +1,4 @@
 import type { PackageManagerUserAgentProvider } from '../definitions.js';
-export declare function createProcessPackageManagerUserAgentProvider(): PackageManagerUserAgentProvider;
+export declare class ProcessPackageManagerUserAgentProvider implements PackageManagerUserAgentProvider {
+    readonly userAgent: string | null;
+}

package/dist/cli/info/infra/process-package-manager-user-agent-provider.js

@@ -1,10 +1,7 @@
-function createProcessPackageManagerUserAgentProvider() {
-  return {
-    getUserAgent() {
-      return process.env.npm_config_user_agent ?? null;
-    }
-  };
+class ProcessPackageManagerUserAgentProvider {
+  // https://docs.npmjs.com/cli/v8/using-npm/config#user-agent
+  userAgent = process.env.npm_config_user_agent ?? null;
 }
 export {
-  createProcessPackageManagerUserAgentProvider
+  ProcessPackageManagerUserAgentProvider
 };

package/dist/cli/info/infra/prompts-prompt.d.ts

@@ -1,6 +1,11 @@
 import type { Prompt } from '../definitions.js';
-interface Options {
-    force: boolean;
+export declare class PromptsPrompt implements Prompt {
+    #private;
+    constructor({ force }: {
+        force: boolean;
+    });
+    confirm({ message, defaultValue, }: {
+        message: string;
+        defaultValue?: boolean;
+    }): Promise<boolean>;
 }
-export declare function createPromptsPrompt({ force }: Options): Prompt;
-export {};

package/dist/cli/info/infra/prompts-prompt.js

@@ -1,20 +1,25 @@
 import prompts from "prompts";
-function createPromptsPrompt({ force }) {
-  return {
-    async confirm({ message, defaultValue }) {
-      if (force) {
-        return true;
-      }
-      const { value } = await prompts({
-        type: "confirm",
-        name: "value",
-        message,
-        initial: defaultValue
-      });
-      return value;
+class PromptsPrompt {
+  #force;
+  constructor({ force }) {
+    this.#force = force;
+  }
+  async confirm({
+    message,
+    defaultValue
+  }) {
+    if (this.#force) {
+      return true;
     }
-  };
+    const { value } = await prompts({
+      type: "confirm",
+      name: "value",
+      message,
+      initial: defaultValue
+    });
+    return value;
+  }
 }
 export {
-  createPromptsPrompt
+  PromptsPrompt
 };

package/dist/cli/info/infra/styled-debug-info-formatter.d.ts

@@ -1,7 +1,10 @@
 import type { TextStyler } from '../../definitions.js';
 import type { DebugInfoFormatter } from '../definitions.js';
-interface Options {
-    textStyler: TextStyler;
+import type { DebugInfo } from '../domain/debug-info.js';
+export declare class StyledDebugInfoFormatter implements DebugInfoFormatter {
+    #private;
+    constructor({ textStyler, }: {
+        textStyler: TextStyler;
+    });
+    format(info: DebugInfo): string;
 }
-export declare function createStyledDebugInfoFormatter({ textStyler }: Options): DebugInfoFormatter;
-export {};

package/dist/cli/info/infra/styled-debug-info-formatter.js

@@ -1,25 +1,29 @@
-const MAX_PADDING = 25;
-function createStyledDebugInfoFormatter({ textStyler }) {
-  return {
-    format(info) {
-      let output = "";
-      for (const [label, value] of info) {
-        const padding = MAX_PADDING - label.length;
-        const [first, ...rest] = Array.isArray(value) ? value : [value];
-        let richtext = `
-${textStyler.bold(label)}${" ".repeat(padding)}${textStyler.green(first)}`;
-        if (rest.length > 0) {
-          for (const entry of rest) {
-            richtext += `
-${" ".repeat(MAX_PADDING)}${textStyler.green(entry)}`;
-          }
+class StyledDebugInfoFormatter {
+  #textStyler;
+  #maxPadding = 25;
+  constructor({
+    textStyler
+  }) {
+    this.#textStyler = textStyler;
+  }
+  format(info) {
+    let output = "";
+    for (const [label, value] of info) {
+      const padding = this.#maxPadding - label.length;
+      const [first, ...rest] = Array.isArray(value) ? value : [value];
+      let richtext = `
+${this.#textStyler.bold(label)}${" ".repeat(padding)}${this.#textStyler.green(first)}`;
+      if (rest.length > 0) {
+        for (const entry of rest) {
+          richtext += `
+${" ".repeat(this.#maxPadding)}${this.#textStyler.green(entry)}`;
         }
-        output += richtext;
       }
-      return output.trim();
+      output += richtext;
     }
-  };
+    return output.trim();
+  }
 }
 export {
-  createStyledDebugInfoFormatter
+  StyledDebugInfoFormatter
 };

package/dist/cli/info/infra/yarn-package-manager.d.ts

@@ -1,7 +1,10 @@
 import type { CommandExecutor } from '../../definitions.js';
 import type { PackageManager } from '../definitions.js';
-interface Options {
-    commandExecutor: CommandExecutor;
+export declare class YarnPackageManager implements PackageManager {
+    #private;
+    readonly name: string;
+    constructor({ commandExecutor }: {
+        commandExecutor: CommandExecutor;
+    });
+    getPackageVersion(name: string): Promise<string | undefined>;
 }
-export declare function createYarnPackageManager({ commandExecutor }: Options): PackageManager;
-export {};

package/dist/cli/info/infra/yarn-package-manager.js

@@ -6,29 +6,29 @@ function getYarnOutputDepVersion(dependency, outputLine) {
     }
   }
 }
-function createYarnPackageManager({ commandExecutor }) {
-  return {
-    getName() {
-      return "yarn";
-    },
-    async getPackageVersion(name) {
-      try {
-        const { stdout } = await commandExecutor.execute("yarn", ["why", name, "--json"], {
-          shell: true
-        });
-        const hasUserDefinition = stdout.includes("workspace:.");
-        for (const line of stdout.split("\n")) {
-          if (hasUserDefinition && line.includes("workspace:."))
-            return getYarnOutputDepVersion(name, line);
-          if (!hasUserDefinition && line.includes("astro@"))
-            return getYarnOutputDepVersion(name, line);
-        }
-      } catch {
-        return void 0;
+class YarnPackageManager {
+  name = "yarn";
+  #commandExecutor;
+  constructor({ commandExecutor }) {
+    this.#commandExecutor = commandExecutor;
+  }
+  async getPackageVersion(name) {
+    try {
+      const { stdout } = await this.#commandExecutor.execute("yarn", ["why", name, "--json"], {
+        shell: true
+      });
+      const hasUserDefinition = stdout.includes("workspace:.");
+      for (const line of stdout.split("\n")) {
+        if (hasUserDefinition && line.includes("workspace:."))
+          return getYarnOutputDepVersion(name, line);
+        if (!hasUserDefinition && line.includes("astro@"))
+          return getYarnOutputDepVersion(name, line);
       }
+    } catch {
+      return void 0;
     }
-  };
+  }
 }
 export {
-  createYarnPackageManager
+  YarnPackageManager
 };

package/dist/cli/infra/build-time-astro-version-provider.d.ts

@@ -1,2 +1,4 @@
 import type { AstroVersionProvider } from '../definitions.js';
-export declare function createBuildTimeAstroVersionProvider(): AstroVersionProvider;
+export declare class BuildTimeAstroVersionProvider implements AstroVersionProvider {
+    readonly version: string;
+}

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,11 +1,7 @@
-function createBuildTimeAstroVersionProvider() {
-  const version = "5.16.1";
-  return {
-    get version() {
-      return version;
-    }
-  };
+class BuildTimeAstroVersionProvider {
+  // Injected during the build through esbuild define
+  version = "5.16.2";
 }
 export {
-  createBuildTimeAstroVersionProvider
+  BuildTimeAstroVersionProvider
 };

package/dist/cli/infra/cli-command-runner.d.ts

@@ -1,6 +1,9 @@
 import type { CommandRunner, HelpDisplay } from '../definitions.js';
-interface Options {
-    helpDisplay: HelpDisplay;
+import type { AnyCommand } from '../domain/command.js';
+export declare class CliCommandRunner implements CommandRunner {
+    #private;
+    constructor({ helpDisplay, }: {
+        helpDisplay: HelpDisplay;
+    });
+    run<T extends AnyCommand>(command: T, ...args: Parameters<T['run']>): ReturnType<T['run']> | undefined;
 }
-export declare function createCliCommandRunner({ helpDisplay }: Options): CommandRunner;
-export {};

package/dist/cli/infra/cli-command-runner.js

@@ -1,14 +1,18 @@
-function createCliCommandRunner({ helpDisplay }) {
-  return {
-    run(command, ...args) {
-      if (helpDisplay.shouldFire()) {
-        helpDisplay.show(command.help);
-        return;
-      }
-      return command.run(...args);
+class CliCommandRunner {
+  #helpDisplay;
+  constructor({
+    helpDisplay
+  }) {
+    this.#helpDisplay = helpDisplay;
+  }
+  run(command, ...args) {
+    if (this.#helpDisplay.shouldFire()) {
+      this.#helpDisplay.show(command.help);
+      return;
     }
-  };
+    return command.run(...args);
+  }
 }
 export {
-  createCliCommandRunner
+  CliCommandRunner
 };

package/dist/cli/infra/logger-help-display.d.ts

@@ -1,11 +1,15 @@
 import type { Logger } from '../../core/logger/core.js';
 import type { AstroVersionProvider, HelpDisplay, TextStyler } from '../definitions.js';
+import type { HelpPayload } from '../domain/help-payload.js';
 import type { Flags } from '../flags.js';
-interface Options {
-    logger: Logger;
-    textStyler: TextStyler;
-    astroVersionProvider: AstroVersionProvider;
-    flags: Flags;
+export declare class LoggerHelpDisplay implements HelpDisplay {
+    #private;
+    constructor({ logger, textStyler, astroVersionProvider, flags, }: {
+        logger: Logger;
+        textStyler: TextStyler;
+        astroVersionProvider: AstroVersionProvider;
+        flags: Flags;
+    });
+    shouldFire(): boolean;
+    show({ commandName, description, headline, tables, usage }: HelpPayload): void;
 }
-export declare function createLoggerHelpDisplay({ logger, flags, textStyler, astroVersionProvider, }: Options): HelpDisplay;
-export {};