astro 1.4.7 → 1.5.1

package/dist/core/add/index.js

@@ -2,13 +2,18 @@ import boxen from "boxen";
 import { diffWords } from "diff";
 import { execa } from "execa";
 import { existsSync, promises as fs } from "fs";
-import { bold, cyan, dim, green, magenta, yellow } from "kleur/colors";
+import { bold, cyan, dim, green, magenta, red, yellow } from "kleur/colors";
 import ora from "ora";
 import path from "path";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import { fileURLToPath, pathToFileURL } from "url";
-import { resolveConfigPath } from "../config/index.js";
+import { loadTSConfig, resolveConfigPath } from "../config/index.js";
+import {
+  defaultTSConfig,
+  presets,
+  updateTSConfigForFramework
+} from "../config/tsconfig.js";
 import { debug, info } from "../logger/core.js";
 import * as msg from "../messages.js";
 import { printHelp } from "../messages.js";
@@ -212,7 +217,7 @@ async function add(names, { cwd, flags, logging, telemetry }) {
   switch (configResult) {
     case UpdateResult.cancelled: {
       info(logging, null, msg.cancelled(`Your configuration has ${bold("NOT")} been updated.`));
-      return;
+      break;
     }
     case UpdateResult.none: {
       const pkgURL = new URL("./package.json", configURL);
@@ -224,11 +229,11 @@ async function add(names, { cwd, flags, logging, telemetry }) {
         );
         if (missingDeps.length === 0) {
           info(logging, null, msg.success(`Configuration up-to-date.`));
-          return;
+          break;
         }
       }
       info(logging, null, msg.success(`Configuration up-to-date.`));
-      return;
+      break;
     }
     default: {
       const list = integrations.map((integration) => `  - ${integration.packageName}`).join("\n");
@@ -242,6 +247,27 @@ ${list}`
       );
     }
   }
+  const updateTSConfigResult = await updateTSConfig(cwd, logging, integrations, flags);
+  switch (updateTSConfigResult) {
+    case UpdateResult.none: {
+      break;
+    }
+    case UpdateResult.cancelled: {
+      info(
+        logging,
+        null,
+        msg.cancelled(`Your TypeScript configuration has ${bold("NOT")} been updated.`)
+      );
+      break;
+    }
+    case UpdateResult.failure: {
+      throw new Error(
+        `Unknown error parsing tsconfig.json or jsconfig.json. Could not update TypeScript settings.`
+      );
+    }
+    default:
+      info(logging, null, msg.success(`Successfully updated TypeScript settings`));
+  }
 }
 function isAdapter(integration) {
   return integration.type === "adapter";
@@ -392,27 +418,12 @@ ${defaultExport}`);
   if (input === output) {
     return 0 /* none */;
   }
-  let changes = [];
-  for (const change of diffWords(input, output)) {
-    let lines = change.value.trim().split("\n").slice(0, change.count);
-    if (lines.length === 0)
-      continue;
-    if (change.added) {
-      if (!change.value.trim())
-        continue;
-      changes.push(change.value);
-    }
-  }
-  if (changes.length === 0) {
+  const diff = getDiffContent(input, output);
+  if (!diff) {
     return 0 /* none */;
   }
-  let diffed = output;
-  for (let newContent of changes) {
-    const coloredOutput = newContent.split("\n").map((ln) => ln ? green(ln) : "").join("\n");
-    diffed = diffed.replace(newContent, coloredOutput);
-  }
   const message = `
-${boxen(diffed, {
+${boxen(diff, {
     margin: 0.5,
     padding: 0.5,
     borderStyle: "round",
@@ -464,7 +475,7 @@ async function getInstallIntegrationsCommand({
     case "yarn":
       return { pm: "yarn", command: "add", flags: [], dependencies };
     case "pnpm":
-      return { pm: "pnpm", command: "install", flags: [], dependencies };
+      return { pm: "pnpm", command: "add", flags: [], dependencies };
     default:
       return null;
   }
@@ -616,6 +627,90 @@ async function validateIntegrations(integrations) {
     }
   }
 }
+async function updateTSConfig(cwd = process.cwd(), logging, integrationsInfo, flags) {
+  var _a, _b;
+  const integrations = integrationsInfo.map(
+    (integration) => integration.id
+  );
+  const firstIntegrationWithTSSettings = integrations.find(
+    (integration) => presets.has(integration)
+  );
+  if (!firstIntegrationWithTSSettings) {
+    return 0 /* none */;
+  }
+  const inputConfig = loadTSConfig(cwd, false);
+  const configFileName = inputConfig.exists ? inputConfig.path.split("/").pop() : "tsconfig.json";
+  if (inputConfig.reason === "invalid-config") {
+    return 3 /* failure */;
+  }
+  if (inputConfig.reason === "not-found") {
+    debug("add", "Couldn't find tsconfig.json or jsconfig.json, generating one");
+  }
+  const outputConfig = updateTSConfigForFramework(
+    inputConfig.exists ? inputConfig.config : defaultTSConfig,
+    firstIntegrationWithTSSettings
+  );
+  const input = inputConfig.exists ? JSON.stringify(inputConfig.config, null, 2) : "";
+  const output = JSON.stringify(outputConfig, null, 2);
+  const diff = getDiffContent(input, output);
+  if (!diff) {
+    return 0 /* none */;
+  }
+  const message = `
+${boxen(diff, {
+    margin: 0.5,
+    padding: 0.5,
+    borderStyle: "round",
+    title: configFileName
+  })}
+`;
+  info(
+    logging,
+    null,
+    `
+  ${magenta(`Astro will make the following changes to your ${configFileName}:`)}
+${message}`
+  );
+  const conflictingIntegrations = [...Object.keys(presets).filter((config) => config !== "vue")];
+  const hasConflictingIntegrations = integrations.filter((integration) => presets.has(integration)).length > 1 && integrations.filter((integration) => conflictingIntegrations.includes(integration)).length > 0;
+  if (hasConflictingIntegrations) {
+    info(
+      logging,
+      null,
+      red(
+        `  ${bold(
+          "Caution:"
+        )} Selected UI frameworks require conflicting tsconfig.json settings, as such only settings for ${bold(
+          firstIntegrationWithTSSettings
+        )} were used.
+  More information: https://docs.astro.build/en/guides/typescript/#errors-typing-multiple-jsx-frameworks-at-the-same-time
+`
+      )
+    );
+  }
+  if (integrations.includes("vue") && hasConflictingIntegrations && (((_a = outputConfig.compilerOptions) == null ? void 0 : _a.jsx) !== "preserve" && ((_b = outputConfig.compilerOptions) == null ? void 0 : _b.jsxImportSource) !== void 0 || integrations.includes("react"))) {
+    info(
+      logging,
+      null,
+      red(
+        `  ${bold(
+          "Caution:"
+        )} Using Vue together with a JSX framework can lead to type checking issues inside Vue files.
+  More information: https://docs.astro.build/en/guides/typescript/#vue-components-are-mistakenly-typed-by-the-typesreact-package-when-installed
+`
+      )
+    );
+  }
+  if (await askToContinue({ flags })) {
+    await fs.writeFile((inputConfig == null ? void 0 : inputConfig.path) ?? path.join(cwd, "tsconfig.json"), output, {
+      encoding: "utf-8"
+    });
+    debug("add", `Updated ${configFileName} file`);
+    return 1 /* updated */;
+  } else {
+    return 2 /* cancelled */;
+  }
+}
 function parseIntegrationName(spec) {
   const result = parseNpmName(spec);
   if (!result)
@@ -643,6 +738,28 @@ async function askToContinue({ flags }) {
   });
   return Boolean(response.askToContinue);
 }
+function getDiffContent(input, output) {
+  let changes = [];
+  for (const change of diffWords(input, output)) {
+    let lines = change.value.trim().split("\n").slice(0, change.count);
+    if (lines.length === 0)
+      continue;
+    if (change.added) {
+      if (!change.value.trim())
+        continue;
+      changes.push(change.value);
+    }
+  }
+  if (changes.length === 0) {
+    return null;
+  }
+  let diffed = output;
+  for (let newContent of changes) {
+    const coloredOutput = newContent.split("\n").map((ln) => ln ? green(ln) : "").join("\n");
+    diffed = diffed.replace(newContent, coloredOutput);
+  }
+  return diffed;
+}
 export {
   add as default,
   validateIntegrations

package/dist/core/app/index.js

@@ -20,14 +20,18 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _manifest, _manifestData, _routeDataToRouteInfo, _routeCache, _encoder, _logging, _streaming, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
+var _env, _manifest, _manifestData, _routeDataToRouteInfo, _encoder, _logging, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
 import mime from "mime";
-import { getSetCookiesFromResponse } from "../cookies/index.js";
+import { attachToResponse, getSetCookiesFromResponse } from "../cookies/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
 import { consoleLogDestination } from "../logger/console.js";
 import { error } from "../logger/core.js";
 import { joinPaths, prependForwardSlash } from "../path.js";
-import { render } from "../render/core.js";
+import {
+  createEnvironment,
+  createRenderContext,
+  renderPage
+} from "../render/index.js";
 import { RouteCache } from "../render/route-cache.js";
 import {
   createLinkStylesheetElementSet,
@@ -41,23 +45,46 @@ class App {
   constructor(manifest, streaming = true) {
     __privateAdd(this, _renderPage);
     __privateAdd(this, _callEndpoint);
+    __privateAdd(this, _env, void 0);
     __privateAdd(this, _manifest, void 0);
     __privateAdd(this, _manifestData, void 0);
     __privateAdd(this, _routeDataToRouteInfo, void 0);
-    __privateAdd(this, _routeCache, void 0);
     __privateAdd(this, _encoder, new TextEncoder());
     __privateAdd(this, _logging, {
       dest: consoleLogDestination,
       level: "info"
     });
-    __privateAdd(this, _streaming, void 0);
     __privateSet(this, _manifest, manifest);
     __privateSet(this, _manifestData, {
       routes: manifest.routes.map((route) => route.routeData)
     });
     __privateSet(this, _routeDataToRouteInfo, new Map(manifest.routes.map((route) => [route.routeData, route])));
-    __privateSet(this, _routeCache, new RouteCache(__privateGet(this, _logging)));
-    __privateSet(this, _streaming, streaming);
+    __privateSet(this, _env, createEnvironment({
+      adapterName: manifest.adapterName,
+      logging: __privateGet(this, _logging),
+      markdown: manifest.markdown,
+      mode: "production",
+      renderers: manifest.renderers,
+      async resolve(specifier) {
+        if (!(specifier in manifest.entryModules)) {
+          throw new Error(`Unable to resolve [${specifier}]`);
+        }
+        const bundlePath = manifest.entryModules[specifier];
+        switch (true) {
+          case bundlePath.startsWith("data:"):
+          case bundlePath.length === 0: {
+            return bundlePath;
+          }
+          default: {
+            return prependForwardSlash(joinPaths(manifest.base, bundlePath));
+          }
+        }
+      },
+      routeCache: new RouteCache(__privateGet(this, _logging)),
+      site: __privateGet(this, _manifest).site,
+      ssr: true,
+      streaming
+    }));
   }
   match(request, { matchNotFound = false } = {}) {
     const url = new URL(request.url);
@@ -116,13 +143,12 @@ class App {
     return getSetCookiesFromResponse(response);
   }
 }
+_env = new WeakMap();
 _manifest = new WeakMap();
 _manifestData = new WeakMap();
 _routeDataToRouteInfo = new WeakMap();
-_routeCache = new WeakMap();
 _encoder = new WeakMap();
 _logging = new WeakMap();
-_streaming = new WeakMap();
 _renderPage = new WeakSet();
 renderPage_fn = async function(request, routeData, mod, status = 200) {
   const url = new URL(request.url);
@@ -144,40 +170,16 @@ renderPage_fn = async function(request, routeData, mod, status = 200) {
     }
   }
   try {
-    const response = await render({
-      adapterName: manifest.adapterName,
-      links,
-      logging: __privateGet(this, _logging),
-      markdown: manifest.markdown,
-      mod,
-      mode: "production",
+    const ctx = createRenderContext({
+      request,
       origin: url.origin,
       pathname: url.pathname,
       scripts,
-      renderers,
-      async resolve(specifier) {
-        if (!(specifier in manifest.entryModules)) {
-          throw new Error(`Unable to resolve [${specifier}]`);
-        }
-        const bundlePath = manifest.entryModules[specifier];
-        switch (true) {
-          case bundlePath.startsWith("data:"):
-          case bundlePath.length === 0: {
-            return bundlePath;
-          }
-          default: {
-            return prependForwardSlash(joinPaths(manifest.base, bundlePath));
-          }
-        }
-      },
+      links,
       route: routeData,
-      routeCache: __privateGet(this, _routeCache),
-      site: __privateGet(this, _manifest).site,
-      ssr: true,
-      request,
-      streaming: __privateGet(this, _streaming),
       status
     });
+    const response = await renderPage(mod, ctx, __privateGet(this, _env));
     return response;
   } catch (err) {
     error(__privateGet(this, _logging), "ssr", err.stack || err.message || String(err));
@@ -191,16 +193,14 @@ _callEndpoint = new WeakSet();
 callEndpoint_fn = async function(request, routeData, mod, status = 200) {
   const url = new URL(request.url);
   const handler = mod;
-  const result = await callEndpoint(handler, {
-    logging: __privateGet(this, _logging),
+  const ctx = createRenderContext({
+    request,
     origin: url.origin,
     pathname: url.pathname,
-    request,
     route: routeData,
-    routeCache: __privateGet(this, _routeCache),
-    ssr: true,
     status
   });
+  const result = await callEndpoint(handler, __privateGet(this, _env), ctx);
   if (result.type === "response") {
     if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
       const fourOhFourRequest = new Request(new URL("/404", request.url));
@@ -221,10 +221,12 @@ callEndpoint_fn = async function(request, routeData, mod, status = 200) {
     }
     const bytes = __privateGet(this, _encoder).encode(body);
     headers.set("Content-Length", bytes.byteLength.toString());
-    return new Response(bytes, {
+    const response = new Response(bytes, {
       status: 200,
       headers
     });
+    attachToResponse(response, result.cookies);
+    return response;
   }
 };
 export {

package/dist/core/build/generate.js

@@ -13,7 +13,7 @@ import { runHookBuildGenerated } from "../../integrations/index.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
 import { debug, info } from "../logger/core.js";
-import { render } from "../render/core.js";
+import { createEnvironment, createRenderContext, renderPage } from "../render/index.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
 import { createLinkStylesheetElementSet, createModuleScriptsSet } from "../render/ssr-element.js";
 import { createRequest } from "../request.js";
@@ -234,19 +234,14 @@ async function generatePath(pathname, opts, gopts) {
     opts.settings.config.build.format,
     pageData.route.type
   );
-  const options = {
+  const env = createEnvironment({
     adapterName: void 0,
-    links,
     logging,
     markdown: {
       ...settings.config.markdown,
       isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
     },
-    mod,
     mode: opts.mode,
-    origin,
-    pathname,
-    scripts,
     renderers,
     async resolve(specifier) {
       const hashedFilePath = internals.entrySpecifierToBundleMap.get(specifier);
@@ -258,24 +253,31 @@ async function generatePath(pathname, opts, gopts) {
       }
       return prependForwardSlash(npath.posix.join(settings.config.base, hashedFilePath));
     },
-    request: createRequest({ url, headers: new Headers(), logging, ssr }),
-    route: pageData.route,
     routeCache,
     site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
     ssr,
     streaming: true
-  };
+  });
+  const ctx = createRenderContext({
+    origin,
+    pathname,
+    request: createRequest({ url, headers: new Headers(), logging, ssr }),
+    scripts,
+    links,
+    route: pageData.route
+  });
   let body;
   let encoding;
   if (pageData.route.type === "endpoint") {
-    const result = await callEndpoint(mod, options);
+    const endpointHandler = mod;
+    const result = await callEndpoint(endpointHandler, env, ctx);
     if (result.type === "response") {
       throw new Error(`Returning a Response from an endpoint is not supported in SSG mode.`);
     }
     body = result.body;
     encoding = result.encoding;
   } else {
-    const response = await render(options);
+    const response = await renderPage(mod, ctx, env);
     if (response.status !== 200 || !response.body) {
       return;
     }

package/dist/core/build/index.js

@@ -59,9 +59,9 @@ class AstroBuilder {
   }
   async build({ viteConfig }) {
     const buildConfig = {
-      client: new URL("./client/", this.settings.config.outDir),
-      server: new URL("./server/", this.settings.config.outDir),
-      serverEntry: "entry.mjs"
+      client: this.settings.config.build.client,
+      server: this.settings.config.build.server,
+      serverEntry: this.settings.config.build.serverEntry
     };
     await runHookBuildStart({ config: this.settings.config, buildConfig, logging: this.logging });
     this.validateConfig();

package/dist/core/config/config.d.ts

@@ -14,7 +14,7 @@ interface LoadConfigOptions {
     validate?: boolean;
     logging: LogOptions;
     /** Invalidate when reloading a previously loaded config */
-    isConfigReload?: boolean;
+    isRestart?: boolean;
 }
 /**
  * Resolve the file URL of the user's `astro.config.js|cjs|mjs|ts` file

package/dist/core/config/config.js

@@ -6,7 +6,7 @@ import path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 import * as vite from "vite";
 import { mergeConfig as mergeViteConfig } from "vite";
-import { arraify, isObject } from "../util.js";
+import { arraify, isObject, isURL } from "../util.js";
 import { createRelativeSchema } from "./schema.js";
 load.use([loadTypeScript]);
 const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -150,7 +150,7 @@ async function tryLoadConfig(configOptions, flags, root) {
     });
     if (!configPath)
       return void 0;
-    if (configOptions.isConfigReload) {
+    if (configOptions.isRestart) {
       const tempConfigPath = path.join(
         root,
         `.temp.${Date.now()}.config${path.extname(configPath)}`
@@ -237,6 +237,10 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
       merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
       continue;
     }
+    if (isURL(existing) && isURL(value)) {
+      merged[key] = value;
+      continue;
+    }
     if (isObject(existing) && isObject(value)) {
       merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
       continue;

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

@@ -1,4 +1,4 @@
 export { openConfig, resolveConfigPath, resolveFlags, resolveRoot, validateConfig, } from './config.js';
 export type { AstroConfigSchema } from './schema';
 export { createSettings } from './settings.js';
-export { loadTSConfig } from './tsconfig.js';
+export { loadTSConfig, updateTSConfigForFramework } from './tsconfig.js';

package/dist/core/config/index.js

@@ -6,7 +6,7 @@ import {
   validateConfig
 } from "./config.js";
 import { createSettings } from "./settings.js";
-import { loadTSConfig } from "./tsconfig.js";
+import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
 export {
   createSettings,
   loadTSConfig,
@@ -14,5 +14,6 @@ export {
   resolveConfigPath,
   resolveFlags,
   resolveRoot,
+  updateTSConfigForFramework,
   validateConfig
 };