astro 1.4.6 → 1.5.0

package/dist/core/config/tsconfig.js

@@ -1,13 +1,79 @@
+import { deepmerge } from "deepmerge-ts";
+import { existsSync } from "fs";
+import { join } from "path";
 import * as tsr from "tsconfig-resolver";
-function loadTSConfig(cwd) {
-  for (const searchName of ["tsconfig.json", "jsconfig.json"]) {
-    const config = tsr.tsconfigResolverSync({ cwd, searchName });
-    if (config.exists) {
-      return config;
+const defaultTSConfig = { extends: "astro/tsconfigs/base" };
+const presets = /* @__PURE__ */ new Map([
+  [
+    "vue",
+    {
+      compilerOptions: {
+        jsx: "preserve"
+      }
     }
+  ],
+  [
+    "react",
+    {
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "react"
+      }
+    }
+  ],
+  [
+    "preact",
+    {
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "preact"
+      }
+    }
+  ],
+  [
+    "solid-js",
+    {
+      compilerOptions: {
+        jsx: "preserve",
+        jsxImportSource: "solid-js"
+      }
+    }
+  ]
+]);
+function loadTSConfig(cwd, resolve = true) {
+  cwd = cwd ?? process.cwd();
+  let config = tsr.tsconfigResolverSync({
+    cwd,
+    filePath: resolve ? void 0 : cwd
+  });
+  if (!resolve && config.reason === "invalid-config" && !existsSync(join(cwd, "tsconfig.json"))) {
+    config = { reason: "not-found", path: void 0, exists: false };
+  } else {
+    return config;
+  }
+  if (config.reason === "not-found") {
+    const jsconfig = tsr.tsconfigResolverSync({
+      cwd,
+      filePath: resolve ? void 0 : cwd,
+      searchName: "jsconfig.json"
+    });
+    if (!resolve && jsconfig.reason === "invalid-config" && !existsSync(join(cwd, "jsconfig.json"))) {
+      return { reason: "not-found", path: void 0, exists: false };
+    } else {
+      return jsconfig;
+    }
+  }
+  return config;
+}
+function updateTSConfigForFramework(target, framework) {
+  if (!presets.has(framework)) {
+    return target;
   }
-  return void 0;
+  return deepmerge(target, presets.get(framework));
 }
 export {
-  loadTSConfig
+  defaultTSConfig,
+  loadTSConfig,
+  presets,
+  updateTSConfigForFramework
 };

package/dist/core/constants.d.ts

@@ -0,0 +1 @@
+export declare const ASTRO_VERSION: string;

package/dist/core/constants.js

@@ -0,0 +1,4 @@
+const ASTRO_VERSION = "1.5.0";
+export {
+  ASTRO_VERSION
+};

package/dist/core/cookies/cookies.d.ts

@@ -19,7 +19,7 @@ interface AstroCookieInterface {
 interface AstroCookiesInterface {
     get(key: string): AstroCookieInterface;
     has(key: string): boolean;
-    set(key: string, value: string | Record<string, any>, options?: AstroCookieSetOptions): void;
+    set(key: string, value: string | number | boolean | Record<string, any>, options?: AstroCookieSetOptions): void;
     delete(key: string, options?: AstroCookieDeleteOptions): void;
 }
 declare class AstroCookie implements AstroCookieInterface {

package/dist/core/dev/index.js

@@ -16,7 +16,12 @@ async function dev(settings, options) {
   const devStart = performance.now();
   applyPolyfill();
   await options.telemetry.record([]);
-  settings = await runHookConfigSetup({ settings, command: "dev", logging: options.logging });
+  settings = await runHookConfigSetup({
+    settings,
+    command: "dev",
+    logging: options.logging,
+    isRestart: options.isRestart
+  });
   const { host, port } = settings.config.server;
   const { isRestart = false } = options;
   const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
@@ -49,7 +54,7 @@ async function dev(settings, options) {
       isRestart
     })
   );
-  const currentVersion = "1.4.6";
+  const currentVersion = "1.5.0";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/dev/index.js

@@ -1,10 +1,13 @@
 import { preload } from "../../render/dev/index.js";
 import { call as callEndpoint } from "../index.js";
 async function call(ssrOpts) {
+  var _a;
   const [, mod] = await preload(ssrOpts);
   return await callEndpoint(mod, {
     ...ssrOpts,
-    ssr: ssrOpts.settings.config.output === "server"
+    ssr: ssrOpts.settings.config.output === "server",
+    site: ssrOpts.settings.config.site,
+    adapterName: (_a = ssrOpts.settings.config.adapter) == null ? void 0 : _a.name
   });
 }
 export {

package/dist/core/endpoint/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { EndpointHandler } from '../../@types/astro';
 import type { RenderOptions } from '../render/core';
-export declare type EndpointOptions = Pick<RenderOptions, 'logging' | 'origin' | 'request' | 'route' | 'routeCache' | 'pathname' | 'route' | 'site' | 'ssr' | 'status'>;
+export declare type EndpointOptions = Pick<RenderOptions, 'logging' | 'origin' | 'request' | 'route' | 'routeCache' | 'pathname' | 'route' | 'site' | 'ssr' | 'status' | 'adapterName'>;
 declare type EndpointCallResult = {
     type: 'simple';
     body: string;

package/dist/core/endpoint/index.js

@@ -1,11 +1,45 @@
 import { renderEndpoint } from "../../runtime/server/index.js";
+import { ASTRO_VERSION } from "../constants.js";
 import { AstroCookies, attachToResponse } from "../cookies/index.js";
 import { getParamsAndProps, GetParamsAndPropsError } from "../render/core.js";
-function createAPIContext(request, params) {
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+function createAPIContext({
+  request,
+  params,
+  site,
+  props,
+  adapterName
+}) {
   return {
     cookies: new AstroCookies(request),
     request,
-    params
+    params,
+    site: site ? new URL(site) : void 0,
+    generator: `Astro v${ASTRO_VERSION}`,
+    props,
+    redirect(path, status) {
+      return new Response(null, {
+        status: status || 302,
+        headers: {
+          Location: path
+        }
+      });
+    },
+    url: new URL(request.url),
+    get clientAddress() {
+      if (!(clientAddressSymbol in request)) {
+        if (adapterName) {
+          throw new Error(
+            `clientAddress is not available in the ${adapterName} adapter. File an issue with the adapter to add support.`
+          );
+        } else {
+          throw new Error(
+            `clientAddress is not available in your environment. Ensure that you are using an SSR adapter that supports this feature.`
+          );
+        }
+      }
+      return Reflect.get(request, clientAddressSymbol);
+    }
   };
 }
 async function call(mod, opts) {
@@ -15,8 +49,14 @@ async function call(mod, opts) {
       `[getStaticPath] route pattern matched, but no matching static path found. (${opts.pathname})`
     );
   }
-  const [params] = paramsAndPropsResp;
-  const context = createAPIContext(opts.request, params);
+  const [params, props] = paramsAndPropsResp;
+  const context = createAPIContext({
+    request: opts.request,
+    params,
+    props,
+    site: opts.site,
+    adapterName: opts.adapterName
+  });
   const response = await renderEndpoint(mod, context, opts.ssr);
   if (response instanceof Response) {
     attachToResponse(response, context.cookies);

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   site,
   isRestart = false
 }) {
-  const version = "1.4.6";
+  const version = "1.5.0";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -250,7 +250,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.4.6"}`
+        `v${"1.5.0"}`
       )} ${headline}`
     );
   }

package/dist/core/preview/index.d.ts

@@ -1,19 +1,10 @@
-/// <reference types="node" />
 import type { AstroTelemetry } from '@astrojs/telemetry';
-import type { AstroSettings } from '../../@types/astro';
+import type { AstroSettings, PreviewServer } from '../../@types/astro';
 import type { LogOptions } from '../logger/core';
-import http from 'http';
 interface PreviewOptions {
     logging: LogOptions;
     telemetry: AstroTelemetry;
 }
-export interface PreviewServer {
-    host?: string;
-    port: number;
-    server: http.Server;
-    closed(): Promise<void>;
-    stop(): Promise<void>;
-}
 /** The primary dev action */
-export default function preview(settings: AstroSettings, { logging }: PreviewOptions): Promise<PreviewServer>;
+export default function preview(_settings: AstroSettings, { logging }: PreviewOptions): Promise<PreviewServer>;
 export {};

package/dist/core/preview/index.js

@@ -1,134 +1,40 @@
-import fs from "fs";
-import http from "http";
-import { performance } from "perf_hooks";
-import sirv from "sirv";
-import { fileURLToPath } from "url";
-import { notFoundTemplate, subpathNotUsedTemplate } from "../../template/4xx.js";
-import { error, info } from "../logger/core.js";
-import * as msg from "../messages.js";
+import { createRequire } from "module";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/index.js";
+import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
-const HAS_FILE_EXTENSION_REGEXP = /^.*\.[^\\]+$/;
-async function preview(settings, { logging }) {
-  if (settings.config.output === "server") {
-    throw new Error(
-      `[preview] 'output: server' not supported. Use your deploy platform's preview command directly instead, if one exists. (ex: 'netlify dev', 'vercel dev', 'wrangler', etc.)`
-    );
-  }
-  const startServerTime = performance.now();
-  const defaultOrigin = "http://localhost";
-  const trailingSlash = settings.config.trailingSlash;
-  let baseURL = new URL(settings.config.base, new URL(settings.config.site || "/", defaultOrigin));
-  const staticFileServer = sirv(fileURLToPath(settings.config.outDir), {
-    dev: true,
-    etag: true,
-    maxAge: 0
-  });
-  const server = http.createServer((req, res) => {
-    var _a;
-    const requestURL = new URL(req.url, defaultOrigin);
-    if (!requestURL.pathname.startsWith(baseURL.pathname)) {
-      res.statusCode = 404;
-      res.end(subpathNotUsedTemplate(baseURL.pathname, requestURL.pathname));
-      return;
-    }
-    const pathname = requestURL.pathname.slice(baseURL.pathname.length - 1);
-    const isRoot = pathname === "/";
-    const hasTrailingSlash = isRoot || pathname.endsWith("/");
-    function sendError(message) {
-      res.statusCode = 404;
-      res.end(notFoundTemplate(pathname, message));
-    }
-    switch (true) {
-      case (hasTrailingSlash && trailingSlash == "never" && !isRoot):
-        sendError('Not Found (trailingSlash is set to "never")');
-        return;
-      case (!hasTrailingSlash && trailingSlash == "always" && !isRoot && !HAS_FILE_EXTENSION_REGEXP.test(pathname)):
-        sendError('Not Found (trailingSlash is set to "always")');
-        return;
-      default: {
-        req.url = "/" + ((_a = req.url) == null ? void 0 : _a.replace(baseURL.pathname, ""));
-        staticFileServer(req, res, () => {
-          const errorPagePath = fileURLToPath(settings.config.outDir + "/404.html");
-          if (fs.existsSync(errorPagePath)) {
-            res.statusCode = 404;
-            res.setHeader("Content-Type", "text/html;charset=utf-8");
-            res.end(fs.readFileSync(errorPagePath));
-          } else {
-            staticFileServer(req, res, () => {
-              sendError("Not Found");
-            });
-          }
-        });
-        return;
-      }
-    }
+async function preview(_settings, { logging }) {
+  const settings = await runHookConfigSetup({
+    settings: _settings,
+    command: "preview",
+    logging
   });
-  let { port } = settings.config.server;
+  await runHookConfigDone({ settings, logging });
   const host = getResolvedHostForHttpServer(settings.config.server.host);
-  let httpServer;
-  function startServer(timerStart) {
-    let showedPortTakenMsg = false;
-    let showedListenMsg = false;
-    return new Promise((resolve, reject) => {
-      const listen = () => {
-        httpServer = server.listen(port, host, async () => {
-          if (!showedListenMsg) {
-            const resolvedUrls = msg.resolveServerUrls({
-              address: server.address(),
-              host: settings.config.server.host,
-              https: false
-            });
-            info(
-              logging,
-              null,
-              msg.serverStart({
-                startupTime: performance.now() - timerStart,
-                resolvedUrls,
-                host: settings.config.server.host,
-                site: baseURL
-              })
-            );
-          }
-          showedListenMsg = true;
-          resolve();
-        });
-        httpServer == null ? void 0 : httpServer.on("error", onError);
-      };
-      const onError = (err) => {
-        if (err.code && err.code === "EADDRINUSE") {
-          if (!showedPortTakenMsg) {
-            info(logging, "astro", msg.portInUse({ port }));
-            showedPortTakenMsg = true;
-          }
-          port++;
-          return listen();
-        } else {
-          error(logging, "astro", err.stack || err.message);
-          httpServer == null ? void 0 : httpServer.removeListener("error", onError);
-          reject(err);
-        }
-      };
-      listen();
-    });
+  const { port } = settings.config.server;
+  if (settings.config.output === "static") {
+    const server2 = await createStaticPreviewServer(settings, { logging, host, port });
+    return server2;
+  }
+  if (!settings.adapter) {
+    throw new Error(`[preview] No adapter found.`);
   }
-  await startServer(startServerTime);
-  function closed() {
-    return new Promise((resolve, reject) => {
-      httpServer.addListener("close", resolve);
-      httpServer.addListener("error", reject);
-    });
+  if (!settings.adapter.previewEntrypoint) {
+    throw new Error(`[preview] adapter does not have previewEntrypoint.`);
   }
-  return {
+  const require2 = createRequire(settings.config.root);
+  const previewEntrypoint = require2.resolve(settings.adapter.previewEntrypoint);
+  const previewModule = await import(previewEntrypoint);
+  if (typeof previewModule.default !== "function") {
+    throw new Error(`[preview] ${settings.adapter.name} cannot preview your app.`);
+  }
+  const server = await previewModule.default({
+    outDir: settings.config.outDir,
+    client: settings.config.build.client,
+    serverEntrypoint: new URL(settings.config.build.serverEntry, settings.config.build.server),
     host,
-    port,
-    closed,
-    server: httpServer,
-    stop: async () => {
-      await new Promise((resolve, reject) => {
-        httpServer.close((err) => err ? reject(err) : resolve(void 0));
-      });
-    }
-  };
+    port
+  });
+  return server;
 }
 export {
   preview as default

package/dist/core/preview/static-preview-server.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { AstroSettings } from '../../@types/astro';
+import type { LogOptions } from '../logger/core';
+import http from 'http';
+export interface PreviewServer {
+    host?: string;
+    port: number;
+    server: http.Server;
+    closed(): Promise<void>;
+    stop(): Promise<void>;
+}
+/** The primary dev action */
+export default function createStaticPreviewServer(settings: AstroSettings, { logging, host, port }: {
+    logging: LogOptions;
+    host: string | undefined;
+    port: number;
+}): Promise<PreviewServer>;

package/dist/core/preview/static-preview-server.js

@@ -0,0 +1,127 @@
+import fs from "fs";
+import http from "http";
+import { performance } from "perf_hooks";
+import sirv from "sirv";
+import { fileURLToPath } from "url";
+import { notFoundTemplate, subpathNotUsedTemplate } from "../../template/4xx.js";
+import { error, info } from "../logger/core.js";
+import * as msg from "../messages.js";
+const HAS_FILE_EXTENSION_REGEXP = /^.*\.[^\\]+$/;
+async function createStaticPreviewServer(settings, { logging, host, port }) {
+  const startServerTime = performance.now();
+  const defaultOrigin = "http://localhost";
+  const trailingSlash = settings.config.trailingSlash;
+  let baseURL = new URL(settings.config.base, new URL(settings.config.site || "/", defaultOrigin));
+  const staticFileServer = sirv(fileURLToPath(settings.config.outDir), {
+    dev: true,
+    etag: true,
+    maxAge: 0
+  });
+  const server = http.createServer((req, res) => {
+    var _a;
+    const requestURL = new URL(req.url, defaultOrigin);
+    if (!requestURL.pathname.startsWith(baseURL.pathname)) {
+      res.statusCode = 404;
+      res.end(subpathNotUsedTemplate(baseURL.pathname, requestURL.pathname));
+      return;
+    }
+    const pathname = requestURL.pathname.slice(baseURL.pathname.length - 1);
+    const isRoot = pathname === "/";
+    const hasTrailingSlash = isRoot || pathname.endsWith("/");
+    function sendError(message) {
+      res.statusCode = 404;
+      res.end(notFoundTemplate(pathname, message));
+    }
+    switch (true) {
+      case (hasTrailingSlash && trailingSlash == "never" && !isRoot):
+        sendError('Not Found (trailingSlash is set to "never")');
+        return;
+      case (!hasTrailingSlash && trailingSlash == "always" && !isRoot && !HAS_FILE_EXTENSION_REGEXP.test(pathname)):
+        sendError('Not Found (trailingSlash is set to "always")');
+        return;
+      default: {
+        req.url = "/" + ((_a = req.url) == null ? void 0 : _a.replace(baseURL.pathname, ""));
+        staticFileServer(req, res, () => {
+          const errorPagePath = fileURLToPath(settings.config.outDir + "/404.html");
+          if (fs.existsSync(errorPagePath)) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "text/html;charset=utf-8");
+            res.end(fs.readFileSync(errorPagePath));
+          } else {
+            staticFileServer(req, res, () => {
+              sendError("Not Found");
+            });
+          }
+        });
+        return;
+      }
+    }
+  });
+  let httpServer;
+  function startServer(timerStart) {
+    let showedPortTakenMsg = false;
+    let showedListenMsg = false;
+    return new Promise((resolve, reject) => {
+      const listen = () => {
+        httpServer = server.listen(port, host, async () => {
+          if (!showedListenMsg) {
+            const resolvedUrls = msg.resolveServerUrls({
+              address: server.address(),
+              host: settings.config.server.host,
+              https: false
+            });
+            info(
+              logging,
+              null,
+              msg.serverStart({
+                startupTime: performance.now() - timerStart,
+                resolvedUrls,
+                host: settings.config.server.host,
+                site: baseURL
+              })
+            );
+          }
+          showedListenMsg = true;
+          resolve();
+        });
+        httpServer == null ? void 0 : httpServer.on("error", onError);
+      };
+      const onError = (err) => {
+        if (err.code && err.code === "EADDRINUSE") {
+          if (!showedPortTakenMsg) {
+            info(logging, "astro", msg.portInUse({ port }));
+            showedPortTakenMsg = true;
+          }
+          port++;
+          return listen();
+        } else {
+          error(logging, "astro", err.stack || err.message);
+          httpServer == null ? void 0 : httpServer.removeListener("error", onError);
+          reject(err);
+        }
+      };
+      listen();
+    });
+  }
+  await startServer(startServerTime);
+  function closed() {
+    return new Promise((resolve, reject) => {
+      httpServer.addListener("close", resolve);
+      httpServer.addListener("error", reject);
+    });
+  }
+  return {
+    host,
+    port,
+    closed,
+    server: httpServer,
+    stop: async () => {
+      await new Promise((resolve, reject) => {
+        httpServer.close((err) => err ? reject(err) : resolve(void 0));
+      });
+    }
+  };
+}
+export {
+  createStaticPreviewServer as default
+};

package/dist/core/render/core.d.ts

@@ -15,7 +15,7 @@ export declare const enum GetParamsAndPropsError {
 }
 export declare function getParamsAndProps(opts: GetParamsAndPropsOptions): Promise<[Params, Props] | GetParamsAndPropsError>;
 export interface RenderOptions {
-    adapterName: string | undefined;
+    adapterName?: string;
     logging: LogOptions;
     links: Set<SSRElement>;
     styles?: Set<SSRElement>;

package/dist/core/render/result.js

@@ -166,9 +166,9 @@ function createResult(args) {
         props,
         request,
         url,
-        redirect: args.ssr ? (path) => {
+        redirect: args.ssr ? (path, status) => {
           return new Response(null, {
-            status: 302,
+            status: status || 302,
             headers: {
               Location: path
             }

package/dist/core/util.d.ts

@@ -1,9 +1,9 @@
-/// <reference types="node" />
 import type { ErrorPayload, ViteDevServer } from 'vite';
 import type { AstroConfig, AstroSettings, RouteType } from '../@types/astro';
-export declare const ASTRO_VERSION: string;
 /** Returns true if argument is an object of any prototype/class (but not null). */
 export declare function isObject(value: unknown): value is Record<string, any>;
+/** Cross-realm compatible URL */
+export declare function isURL(value: unknown): value is URL;
 /** Wraps an object in an array. If an array is passed, ignore it. */
 export declare function arraify<T>(target: T | T[]): T[];
 export declare function padMultilineString(source: string, n?: number): string;
@@ -45,15 +45,4 @@ export declare function getLocalAddress(serverAddress: string, host: string | bo
  */
 export declare function resolveIdToUrl(viteServer: ViteDevServer, id: string): Promise<string>;
 export declare function resolveJsToTs(filePath: string): string;
-export declare const AggregateError: AggregateErrorConstructor | {
-    new (errors: Iterable<any>, message?: string | undefined): {
-        errors: Array<any>;
-        name: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
+export declare const AggregateError: any;

package/dist/core/util.js

@@ -5,10 +5,12 @@ import resolve from "resolve";
 import slash from "slash";
 import { fileURLToPath, pathToFileURL } from "url";
 import { prependForwardSlash, removeTrailingForwardSlash } from "./path.js";
-const ASTRO_VERSION = "1.4.6";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }
+function isURL(value) {
+  return Object.prototype.toString.call(value) === "[object URL]";
+}
 function arraify(target) {
   return Array.isArray(target) ? target : [target];
 }
@@ -175,7 +177,6 @@ const AggregateError = typeof globalThis.AggregateError !== "undefined" ? global
   }
 };
 export {
-  ASTRO_VERSION,
   AggregateError,
   VALID_ID_PREFIX,
   arraify,
@@ -187,6 +188,7 @@ export {
   isModeServerWithNoAdapter,
   isObject,
   isPage,
+  isURL,
   padMultilineString,
   parseNpmName,
   relativeToSrcDir,

package/dist/events/index.js

@@ -1,6 +1,6 @@
 import { AstroTelemetry } from "@astrojs/telemetry";
 import { createRequire } from "module";
-import { ASTRO_VERSION } from "../core/util.js";
+import { ASTRO_VERSION } from "../core/constants.js";
 const require2 = createRequire(import.meta.url);
 function getViteVersion() {
   try {