astro 2.2.3 → 2.3.0

package/dist/assets/consts.d.ts

@@ -1,8 +1,9 @@
 export declare const VIRTUAL_MODULE_ID = "astro:assets";
 export declare const VIRTUAL_SERVICE_ID = "virtual:image-service";
+export declare const VALID_INPUT_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif", "svg"];
 /**
  * Valid formats for optimizations in our base services.
- * Certain formats can be imported (namely SVGs) but not optimized, so they are excluded from this list.
+ * Certain formats can be imported (namely SVGs) but not processed, so they are excluded from this list.
  */
-export declare const VALID_INPUT_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif"];
+export declare const VALID_OPTIMIZABLE_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif"];
 export declare const VALID_OUTPUT_FORMATS: readonly ["avif", "png", "webp", "jpeg", "jpg"];

package/dist/assets/consts.js

@@ -14,11 +14,14 @@ const VALID_INPUT_FORMATS = [
   "png",
   "tiff",
   "webp",
-  "gif"
+  "gif",
+  "svg"
 ];
+const VALID_OPTIMIZABLE_FORMATS = ["jpeg", "jpg", "png", "tiff", "webp", "gif"];
 const VALID_OUTPUT_FORMATS = ["avif", "png", "webp", "jpeg", "jpg"];
 export {
   VALID_INPUT_FORMATS,
+  VALID_OPTIMIZABLE_FORMATS,
   VALID_OUTPUT_FORMATS,
   VIRTUAL_MODULE_ID,
   VIRTUAL_SERVICE_ID

package/dist/assets/services/service.js

@@ -1,5 +1,5 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-import { VALID_INPUT_FORMATS } from "../consts.js";
+import { VALID_OPTIMIZABLE_FORMATS } from "../consts.js";
 import { isESMImportedImage } from "../internal.js";
 function isLocalService(service) {
   if (!service) {
@@ -38,13 +38,13 @@ const baseService = {
         });
       }
     } else {
-      if (!VALID_INPUT_FORMATS.includes(options.src.format)) {
+      if (!VALID_OPTIMIZABLE_FORMATS.includes(options.src.format)) {
         throw new AstroError({
           ...AstroErrorData.UnsupportedImageFormat,
           message: AstroErrorData.UnsupportedImageFormat.message(
             options.src.format,
             options.src.src,
-            VALID_INPUT_FORMATS
+            VALID_OPTIMIZABLE_FORMATS
           )
         });
       }

package/dist/assets/types.d.ts

@@ -2,7 +2,7 @@ import type { VALID_INPUT_FORMATS, VALID_OUTPUT_FORMATS } from './consts.js';
 import type { ImageService } from './services/service.js';
 export type ImageQualityPreset = 'low' | 'mid' | 'high' | 'max' | (string & {});
 export type ImageQuality = ImageQualityPreset | number;
-export type ImageInputFormat = (typeof VALID_INPUT_FORMATS)[number] | 'svg';
+export type ImageInputFormat = (typeof VALID_INPUT_FORMATS)[number];
 export type ImageOutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
 declare global {
     var astroAsset: {

package/dist/content/runtime-assets.d.ts

@@ -1,4 +1,4 @@
 import type { PluginContext } from 'rollup';
 import { z } from 'zod';
 import type { AstroSettings } from '../@types/astro.js';
-export declare function createImage(settings: AstroSettings, pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/utils/metadata.js").Metadata, string>;
+export declare function createImage(settings: AstroSettings, pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/utils/metadata.js").Metadata | z.ZodNever, string>;

package/dist/content/runtime-assets.js

@@ -17,7 +17,7 @@ function createImage(settings, pluginContext, entryFilePath) {
           message: `Image ${imagePath} does not exist. Is the path correct?`,
           fatal: true
         });
-        return z.NEVER;
+        return z.never();
       }
       return metadata;
     });

package/dist/content/types-generator.js

@@ -80,7 +80,12 @@ async function createContentTypesGenerator({
       }
       return { shouldGenerateTypes: true };
     }
-    const fileType = getEntryType(fileURLToPath(event.entry), contentPaths, contentEntryExts);
+    const fileType = getEntryType(
+      fileURLToPath(event.entry),
+      contentPaths,
+      contentEntryExts,
+      settings.config.experimental.assets
+    );
     if (fileType === "ignored") {
       return { shouldGenerateTypes: false };
     }

package/dist/content/utils.d.ts

@@ -63,7 +63,7 @@ export declare function getEntryInfo(params: Pick<ContentPaths, 'contentDir'> &
     entry: URL;
     allowFilesOutsideCollection?: true;
 }): EntryInfo;
-export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[]): 'content' | 'config' | 'ignored' | 'unsupported';
+export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], experimentalAssets: boolean): 'content' | 'config' | 'ignored' | 'unsupported';
 /**
  * Match YAML exception handling from Astro core errors
  * @see 'astro/src/core/errors.ts'

package/dist/content/utils.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { normalizePath } from "vite";
 import { z } from "zod";
+import { VALID_INPUT_FORMATS } from "../assets/consts.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { CONTENT_TYPES_FILE } from "./consts.js";
 import { errorMap } from "./error-map.js";
@@ -113,10 +114,10 @@ function getEntryInfo({
   };
   return res;
 }
-function getEntryType(entryPath, paths, contentFileExts) {
+function getEntryType(entryPath, paths, contentFileExts, experimentalAssets) {
   const { ext, base } = path.parse(entryPath);
   const fileUrl = pathToFileURL(entryPath);
-  if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir) || isOnIgnoreList(base)) {
+  if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir) || isOnIgnoreList(base) || experimentalAssets && isImageAsset(ext)) {
     return "ignored";
   } else if (contentFileExts.includes(ext)) {
     return "content";
@@ -129,6 +130,9 @@ function getEntryType(entryPath, paths, contentFileExts) {
 function isOnIgnoreList(fileName) {
   return [".DS_Store"].includes(fileName);
 }
+function isImageAsset(fileExt) {
+  return VALID_INPUT_FORMATS.includes(fileExt.slice(1));
+}
 function hasUnderscoreBelowContentDirectoryPath(fileUrl, contentDir) {
   const parts = fileUrl.pathname.replace(contentDir.pathname, "").split("/");
   for (const part of parts) {

package/dist/content/vite-plugin-content-imports.js

@@ -68,7 +68,12 @@ function astroContentImportPlugin({
       },
       configureServer(viteServer) {
         viteServer.watcher.on("all", async (event, entry) => {
-          if (CHOKIDAR_MODIFIED_EVENTS.includes(event) && getEntryType(entry, contentPaths, contentEntryExts) === "config") {
+          if (CHOKIDAR_MODIFIED_EVENTS.includes(event) && getEntryType(
+            entry,
+            contentPaths,
+            contentEntryExts,
+            settings.config.experimental.assets
+          ) === "config") {
             for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
               if (isContentFlagImport(modUrl) || Boolean(getContentRendererByViteId(modUrl, settings))) {
                 const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);

package/dist/core/build/static-build.js

@@ -3,6 +3,7 @@ import * as eslexer from "es-module-lexer";
 import glob from "fast-glob";
 import fs from "fs";
 import { bgGreen, bgMagenta, black, dim } from "kleur/colors";
+import path from "path";
 import { fileURLToPath } from "url";
 import * as vite from "vite";
 import {
@@ -292,11 +293,13 @@ async function ssrMoveAssets(opts) {
     cwd: fileURLToPath(serverAssets)
   });
   if (files.length > 0) {
-    await fs.promises.mkdir(clientAssets, { recursive: true });
     await Promise.all(
       files.map(async (filename) => {
         const currentUrl = new URL(filename, appendForwardSlash(serverAssets.toString()));
         const clientUrl = new URL(filename, appendForwardSlash(clientAssets.toString()));
+        const dir = new URL(path.parse(clientUrl.href).dir);
+        if (!fs.existsSync(dir))
+          await fs.promises.mkdir(dir, { recursive: true });
         return fs.promises.rename(currentUrl, clientUrl);
       })
     );

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.2.3";
+const ASTRO_VERSION = "2.3.0";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/dev.js

@@ -53,7 +53,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.2.3";
+  const currentVersion = "2.3.0";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.2.3";
+  const version = "2.3.0";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.2.3"}`
+        `v${"2.3.0"}`
       )} ${headline}`
     );
   }

package/dist/vite-plugin-config-alias/index.d.ts

@@ -1,11 +1,6 @@
+import { type Plugin as VitePlugin } from 'vite';
 import type { AstroSettings } from '../@types/astro';
-import type * as vite from 'vite';
-/** Result of successfully parsed tsconfig.json or jsconfig.json. */
-export declare interface Alias {
-    find: RegExp;
-    replacement: string;
-}
 /** Returns a Vite plugin used to alias paths from tsconfig.json and jsconfig.json. */
 export default function configAliasVitePlugin({ settings, }: {
     settings: AstroSettings;
-}): vite.PluginOption;
+}): VitePlugin | null;

package/dist/vite-plugin-config-alias/index.js

@@ -1,66 +1,91 @@
-import * as path from "path";
-const normalize = (pathname) => String(pathname).split(path.sep).join(path.posix.sep);
+import path from "path";
+import { normalizePath } from "vite";
 const getConfigAlias = (settings) => {
-  const config = settings.tsConfig;
-  const configPath = settings.tsConfigPath;
-  if (!config || !configPath)
+  const { tsConfig, tsConfigPath } = settings;
+  if (!tsConfig || !tsConfigPath || !tsConfig.compilerOptions)
     return null;
-  const compilerOptions = Object(config.compilerOptions);
-  if (!compilerOptions.baseUrl)
+  const { baseUrl, paths } = tsConfig.compilerOptions;
+  if (!baseUrl || !paths)
     return null;
-  const baseUrl = path.posix.resolve(
-    path.posix.dirname(normalize(configPath).replace(/^\/?/, "/")),
-    normalize(compilerOptions.baseUrl)
-  );
+  const resolvedBaseUrl = path.resolve(path.dirname(tsConfigPath), baseUrl);
   const aliases = [];
-  for (let [alias, values] of Object.entries(
-    Object(compilerOptions.paths)
-  )) {
-    values = [].concat(values);
+  for (const [alias, values] of Object.entries(paths)) {
     const find = new RegExp(
       `^${[...alias].map(
         (segment) => segment === "*" ? "(.+)" : segment.replace(/[\\^$*+?.()|[\]{}]/, "\\$&")
       ).join("")}$`
     );
     let matchId = 0;
-    for (let value of values) {
-      const replacement = [...path.posix.resolve(baseUrl, value)].map((segment) => segment === "*" ? `$${++matchId}` : segment === "$" ? "$$" : segment).join("");
+    for (const value of values) {
+      const replacement = [...normalizePath(path.resolve(resolvedBaseUrl, value))].map((segment) => segment === "*" ? `$${++matchId}` : segment === "$" ? "$$" : segment).join("");
       aliases.push({ find, replacement });
     }
   }
   aliases.push({
-    find: /^(?!\.*\/)(.+)$/,
-    replacement: `${[...baseUrl].map((segment) => segment === "$" ? "$$" : segment).join("")}/$1`
+    find: /^(?!\.*\/|\w:)(.+)$/,
+    replacement: `${[...normalizePath(resolvedBaseUrl)].map((segment) => segment === "$" ? "$$" : segment).join("")}/$1`
   });
   return aliases;
 };
 function configAliasVitePlugin({
   settings
 }) {
-  const { config } = settings;
   const configAlias = getConfigAlias(settings);
   if (!configAlias)
-    return {};
-  return {
+    return null;
+  const plugin = {
     name: "astro:tsconfig-alias",
     enforce: "pre",
-    async resolveId(sourceId, importer, options) {
-      const resolvedId = await this.resolve(sourceId, importer, { skipSelf: true, ...options });
-      if (resolvedId)
-        return resolvedId;
+    configResolved(config) {
+      patchCreateResolver(config, plugin);
+    },
+    async resolveId(id, importer, options) {
+      if (isVirtualId(id))
+        return;
       for (const alias of configAlias) {
-        if (alias.find.test(sourceId)) {
-          const aliasedSourceId = sourceId.replace(alias.find, alias.replacement);
-          const resolvedAliasedId = await this.resolve(aliasedSourceId, importer, {
-            skipSelf: true,
-            ...options
-          });
-          if (resolvedAliasedId)
-            return resolvedAliasedId;
+        if (alias.find.test(id)) {
+          const updatedId = id.replace(alias.find, alias.replacement);
+          const resolved = await this.resolve(updatedId, importer, { skipSelf: true, ...options });
+          if (resolved)
+            return resolved;
         }
       }
     }
   };
+  return plugin;
+}
+function patchCreateResolver(config, prePlugin) {
+  const _createResolver = config.createResolver;
+  config.createResolver = function(...args1) {
+    const resolver = _createResolver.apply(config, args1);
+    return async function(...args2) {
+      const id = args2[0];
+      const importer = args2[1];
+      const ssr = args2[3];
+      if (importer == null ? void 0 : importer.includes("node_modules")) {
+        return resolver.apply(_createResolver, args2);
+      }
+      const fakePluginContext = {
+        resolve: (_id, _importer) => resolver(_id, _importer, false, ssr)
+      };
+      const fakeResolveIdOpts = {
+        assertions: {},
+        isEntry: false,
+        ssr
+      };
+      const resolved = await prePlugin.resolveId.apply(fakePluginContext, [
+        id,
+        importer,
+        fakeResolveIdOpts
+      ]);
+      if (resolved)
+        return resolved;
+      return resolver.apply(_createResolver, args2);
+    };
+  };
+}
+function isVirtualId(id) {
+  return id.includes("\0") || id.startsWith("virtual:") || id.startsWith("astro:");
 }
 export {
   configAliasVitePlugin as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.2.3",
+  "version": "2.3.0",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -95,7 +95,7 @@
   "dependencies": {
     "@astrojs/compiler": "^1.3.1",
     "@astrojs/language-server": "^0.28.3",
-    "@astrojs/markdown-remark": "^2.1.3",
+    "@astrojs/markdown-remark": "^2.1.4",
     "@astrojs/telemetry": "^2.1.0",
     "@astrojs/webapi": "^2.1.0",
     "@babel/core": "^7.18.2",
@@ -145,7 +145,7 @@
     "vite": "^4.2.1",
     "vitefu": "^0.2.4",
     "yargs-parser": "^21.0.1",
-    "zod": "^3.17.3"
+    "zod": "^3.20.6"
   },
   "devDependencies": {
     "@playwright/test": "^1.29.2",
@@ -170,7 +170,6 @@
     "@types/server-destroy": "^1.0.1",
     "@types/sharp": "^0.31.1",
     "@types/unist": "^2.0.6",
-    "astro-scripts": "0.0.14",
     "chai": "^4.3.6",
     "cheerio": "^1.0.0-rc.11",
     "eol": "^0.9.1",
@@ -186,7 +185,8 @@
     "sharp": "^0.31.3",
     "srcset-parse": "^1.1.0",
     "undici": "^5.20.0",
-    "unified": "^10.1.2"
+    "unified": "^10.1.2",
+    "astro-scripts": "0.0.14"
   },
   "peerDependencies": {
     "sharp": "^0.31.3"