astro 2.1.5 → 2.1.6

package/dist/content/runtime-assets.js

@@ -1,3 +1,4 @@
+import { pathToFileURL } from "url";
 import { z } from "zod";
 import { imageMetadata } from "../assets/utils/metadata.js";
 function createImage(options) {
@@ -5,9 +6,8 @@ function createImage(options) {
     if (options.assetsDir === "undefined") {
       throw new Error("Enable `experimental.assets` in your Astro config to use image()");
     }
-    return z.string().transform(async (imagePath) => {
-      const fullPath = new URL(imagePath, options.assetsDir);
-      return await getImageMetadata(fullPath);
+    return z.string({ description: "__image" }).transform(async (imagePath) => {
+      return await getImageMetadata(pathToFileURL(imagePath));
     });
   };
 }

package/dist/content/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import matter from 'gray-matter';
 import fsMod from 'node:fs';
-import type { EmitFile } from 'rollup';
+import type { EmitFile, PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings } from '../@types/astro.js';
@@ -57,7 +57,7 @@ export declare function getEntrySlug({ id, collection, slug, unvalidatedSlug, }:
 export declare function getEntryData(entry: EntryInfo & {
     unvalidatedData: Record<string, unknown>;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig): Promise<{
+}, collectionConfig: CollectionConfig, resolver: (idToResolve: string) => ReturnType<PluginContext['resolve']>): Promise<{
     [x: string]: unknown;
 }>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];

package/dist/content/utils.js

@@ -56,7 +56,7 @@ function getEntrySlug({
     });
   }
 }
-async function getEntryData(entry, collectionConfig) {
+async function getEntryData(entry, collectionConfig, resolver) {
   let { slug, ...data } = entry.unvalidatedData;
   if (collectionConfig.schema) {
     if (typeof collectionConfig.schema === "object" && !("safeParseAsync" in collectionConfig.schema)) {
@@ -73,6 +73,32 @@ async function getEntryData(entry, collectionConfig) {
         message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
       });
     }
+    async function preprocessAssetPaths(object) {
+      if (typeof object !== "object" || object === null)
+        return;
+      for (let [schemaName, schema] of Object.entries(object)) {
+        if (schema._def.description === "__image") {
+          object[schemaName] = z.preprocess(
+            async (value) => {
+              var _a;
+              if (!value || typeof value !== "string")
+                return value;
+              return (_a = await resolver(value)) == null ? void 0 : _a.id;
+            },
+            schema,
+            { description: void 0 }
+          );
+        } else if ("shape" in schema) {
+          await preprocessAssetPaths(schema.shape);
+        } else if ("unwrap" in schema) {
+          const unwrapped = schema.unwrap().shape;
+          if (unwrapped) {
+            await preprocessAssetPaths(unwrapped);
+          }
+        }
+      }
+    }
+    await preprocessAssetPaths(collectionConfig.schema.shape);
     const parsed = await collectionConfig.schema.safeParseAsync(entry.unvalidatedData, {
       errorMap
     });

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

@@ -161,7 +161,11 @@ export const _internal = {
     const _internal = { filePath: fileId, rawData };
     const slug = getEntrySlug({ id, collection, slug: generatedSlug, unvalidatedSlug });
     const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
-    let data = collectionConfig ? await getEntryData({ id, collection, slug, _internal, unvalidatedData }, collectionConfig) : unvalidatedData;
+    let data = collectionConfig ? await getEntryData(
+      { id, collection, slug, _internal, unvalidatedData },
+      collectionConfig,
+      (idToResolve) => pluginContext.resolve(idToResolve, fileId)
+    ) : unvalidatedData;
     await patchAssets(data, pluginContext.meta.watchMode, pluginContext.emitFile, settings);
     const contentEntryModule = {
       id,

package/dist/core/constants.js

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

package/dist/core/dev/dev.js

@@ -52,7 +52,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.1.5";
+  const currentVersion = "2.1.6";
   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.1.5";
+  const version = "2.1.6";
   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.1.5"}`
+        `v${"2.1.6"}`
       )} ${headline}`
     );
   }

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

@@ -1,6 +1,11 @@
 import type { AstroSettings } from '../@types/astro';
-import type { Plugin as VitePlugin } from 'vite';
+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;
-}): VitePlugin | null;
+}): vite.PluginOption;

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

@@ -1,55 +1,64 @@
-import path from "path";
-import slash from "slash";
-const getConfigAlias = (paths, baseUrl) => {
+import * as path from "path";
+const normalize = (pathname) => String(pathname).split(path.sep).join(path.posix.sep);
+const getConfigAlias = (settings) => {
+  const config = settings.tsConfig;
+  const configPath = settings.tsConfigPath;
+  if (!config || !configPath)
+    return null;
+  const compilerOptions = Object(config.compilerOptions);
+  if (!compilerOptions.baseUrl)
+    return null;
+  const baseUrl = path.posix.resolve(
+    path.posix.dirname(normalize(configPath).replace(/^\/?/, "/")),
+    normalize(compilerOptions.baseUrl)
+  );
   const aliases = [];
-  for (const [alias, values] of Object.entries(paths)) {
+  for (let [alias, values] of Object.entries(
+    Object(compilerOptions.paths)
+  )) {
+    values = [].concat(values);
     const find = new RegExp(
       `^${[...alias].map(
         (segment) => segment === "*" ? "(.+)" : segment.replace(/[\\^$*+?.()|[\]{}]/, "\\$&")
       ).join("")}$`
     );
     let matchId = 0;
-    for (const value of values) {
+    for (let value of values) {
       const replacement = [...path.posix.resolve(baseUrl, value)].map((segment) => segment === "*" ? `$${++matchId}` : segment === "$" ? "$$" : segment).join("");
       aliases.push({ find, replacement });
     }
   }
+  aliases.push({
+    find: /^(?!\.*\/)(.+)$/,
+    replacement: `${[...baseUrl].map((segment) => segment === "$" ? "$$" : segment).join("")}/$1`
+  });
   return aliases;
 };
 function configAliasVitePlugin({
   settings
 }) {
-  const { tsConfig, tsConfigPath } = settings;
-  if (!tsConfig || !tsConfigPath || !tsConfig.compilerOptions)
-    return null;
-  const { baseUrl, paths } = tsConfig.compilerOptions;
-  if (!baseUrl || !paths)
-    return null;
-  const resolvedBaseUrl = path.posix.resolve(
-    path.posix.dirname(slash(tsConfigPath).replace(/^\/?/, "/")),
-    slash(baseUrl)
-  );
-  const configAlias = getConfigAlias(paths, resolvedBaseUrl);
+  const { config } = settings;
+  const configAlias = getConfigAlias(settings);
+  if (!configAlias)
+    return {};
   return {
     name: "astro:tsconfig-alias",
     enforce: "pre",
-    config() {
-      if (configAlias.length) {
-        return {
-          resolve: {
-            alias: configAlias
-          }
-        };
+    async resolveId(sourceId, importer, options) {
+      const resolvedId = await this.resolve(sourceId, importer, { skipSelf: true, ...options });
+      if (resolvedId)
+        return resolvedId;
+      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;
+        }
       }
-    },
-    async resolveId(id, importer, options) {
-      if (id.startsWith(".") || path.isAbsolute(id))
-        return;
-      const resolved = path.posix.join(resolvedBaseUrl, id);
-      return await this.resolve(resolved, importer, {
-        skipSelf: true,
-        ...options
-      });
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",