michael/astro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

feat: unflag experimental.assets (#7921)

Browse source 
Co-authored-by: Sarah Rainsberger <sarah@rainsberger.ca>
Co-authored-by: Emanuele Stoppa <my.burning@gmail.com>
This commit is contained in:
Erika 2023-08-16 10:21:05 +02:00 committed by GitHub
parent e12a101842
commit b76c166bdd
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
58 changed files with 598 additions and 761 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
.changeset/warm-weeks-yell.md Normal file
View file

@ -0,0 +1,13 @@
---
"astro": major
---
`astro:assets` is now enabled by default. If you were previously using the `experimental.assets` flag, please remove it from your config. Also note that the previous `@astrojs/image` integration is incompatible, and must be removed.
This also brings two important changes to using images in Astro:
- New ESM shape: importing an image will now return an object with different properties describing the image such as its path, format and dimensions. This is a breaking change and may require you to update your existing images.
- In Markdown, MDX, and Markdoc, the `![]()` syntax will now resolve relative images located anywhere in your project in addition to remote images and images stored in the `public/` folder. This notably unlocks storing images next to your content.
Please see our existing [Assets page in Docs](https://docs.astro.build/en/guides/assets/) for more information about using `astro:assets`.

427
packages/astro/client-base.d.ts vendored
View file

@ -1,427 +0,0 @@
/// <reference path="./import-meta.d.ts" />
// eslint-disable-next-line @typescript-eslint/no-namespace
declare namespace App {
// eslint-disable-next-line @typescript-eslint/no-empty-interface
export interface Locals {}
}
interface ImportMetaEnv {
/**
* The prefix for Astro-generated asset links if the build.assetsPrefix config option is set. This can be used to create asset links not handled by Astro.
*/
readonly ASSETS_PREFIX: string;
/**
* This is set to the site option specified in your project’s Astro config file.
*/
readonly SITE: string;
}
interface ImportMeta {
/**
* Astro and Vite expose environment variables through `import.meta.env`. For a complete list of the environment variables available, see the two references below.
*
* - [Astro reference](https://docs.astro.build/en/guides/environment-variables/#default-environment-variables)
* - [Vite reference](https://vitejs.dev/guide/env-and-mode.html#env-variables)
*/
readonly env: ImportMetaEnv;
}
declare module 'astro:assets' {
// Exporting things one by one is a bit cumbersome, not sure if there's a better way - erika, 2023-02-03
type AstroAssets = {
// getImage's type here is different from the internal function since the Vite module implicitly pass the service config
/**
* Get an optimized image and the necessary attributes to render it.
*
* **Example**
* ```astro
* ---
* import { getImage } from 'astro:assets';
* import originalImage from '../assets/image.png';
*
* const optimizedImage = await getImage({src: originalImage, width: 1280 });
* ---
* <img src={optimizedImage.src} {...optimizedImage.attributes} />
* ```
*
* This is functionally equivalent to using the `<Image />` component, as the component calls this function internally.
*/
getImage: (
options:
| import('./dist/assets/types.js').ImageTransform
| import('./dist/assets/types.js').UnresolvedImageTransform
) => Promise<import('./dist/assets/types.js').GetImageResult>;
getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
Image: typeof import('./components/Image.astro').default;
};
type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };
type ImgAttributes = WithRequired<
Omit<import('./types').HTMLAttributes<'img'>, 'src' | 'width' | 'height'>,
'alt'
>;
export type LocalImageProps = Simplify<
import('./dist/assets/types.js').LocalImageProps<ImgAttributes>
>;
export type RemoteImageProps = Simplify<
import('./dist/assets/types.js').RemoteImageProps<ImgAttributes>
>;
export const { getImage, getConfiguredImageService, Image }: AstroAssets;
}
declare module 'astro:transitions' {
type TransitionModule = typeof import('./dist/transitions/index.js');
export const slide: TransitionModule['slide'];
export const fade: TransitionModule['fade'];
type ViewTransitionsModule = typeof import('./components/ViewTransitions.astro');
export const ViewTransitions: ViewTransitionsModule['default'];
}
type MD = import('./dist/@types/astro').MarkdownInstance<Record<string, any>>;
interface ExportedMarkdownModuleEntities {
frontmatter: MD['frontmatter'];
file: MD['file'];
url: MD['url'];
getHeadings: MD['getHeadings'];
/** @deprecated Renamed to `getHeadings()` */
getHeaders: () => void;
Content: MD['Content'];
rawContent: MD['rawContent'];
compiledContent: MD['compiledContent'];
load: MD['default'];
}
declare module '*.md' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.markdown' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mkdn' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mkd' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mdwn' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mdown' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mdx' {
type MDX = import('./dist/@types/astro').MDXInstance<Record<string, any>>;
export const frontmatter: MDX['frontmatter'];
export const file: MDX['file'];
export const url: MDX['url'];
export const getHeadings: MDX['getHeadings'];
export const Content: MDX['Content'];
const load: MDX['default'];
export default load;
}
declare module 'astro:ssr-manifest' {
export const manifest: import('./dist/@types/astro').SSRManifest;
}
// Everything below are Vite's types (apart from image types, which are in `client.d.ts`)
// CSS modules
type CSSModuleClasses = { readonly [key: string]: string };
declare module '*.module.css' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.scss' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.sass' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.less' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.styl' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.stylus' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.pcss' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.sss' {
const classes: CSSModuleClasses;
export default classes;
}
// CSS
declare module '*.css' {
const css: string;
export default css;
}
declare module '*.scss' {
const css: string;
export default css;
}
declare module '*.sass' {
const css: string;
export default css;
}
declare module '*.less' {
const css: string;
export default css;
}
declare module '*.styl' {
const css: string;
export default css;
}
declare module '*.stylus' {
const css: string;
export default css;
}
declare module '*.pcss' {
const css: string;
export default css;
}
declare module '*.sss' {
const css: string;
export default css;
}
// Built-in asset types
// see `src/node/constants.ts`
// images
declare module '*.jfif' {
const src: string;
export default src;
}
declare module '*.pjpeg' {
const src: string;
export default src;
}
declare module '*.pjp' {
const src: string;
export default src;
}
declare module '*.ico' {
const src: string;
export default src;
}
// media
declare module '*.mp4' {
const src: string;
export default src;
}
declare module '*.webm' {
const src: string;
export default src;
}
declare module '*.ogg' {
const src: string;
export default src;
}
declare module '*.mp3' {
const src: string;
export default src;
}
declare module '*.wav' {
const src: string;
export default src;
}
declare module '*.flac' {
const src: string;
export default src;
}
declare module '*.aac' {
const src: string;
export default src;
}
declare module '*.opus' {
const src: string;
export default src;
}
// fonts
declare module '*.woff' {
const src: string;
export default src;
}
declare module '*.woff2' {
const src: string;
export default src;
}
declare module '*.eot' {
const src: string;
export default src;
}
declare module '*.ttf' {
const src: string;
export default src;
}
declare module '*.otf' {
const src: string;
export default src;
}
// other
declare module '*.webmanifest' {
const src: string;
export default src;
}
declare module '*.pdf' {
const src: string;
export default src;
}
declare module '*.txt' {
const src: string;
export default src;
}
// wasm?init
declare module '*.wasm?init' {
const initWasm: (options: WebAssembly.Imports) => Promise<WebAssembly.Instance>;
export default initWasm;
}
// web worker
declare module '*?worker' {
const workerConstructor: {
new (): Worker;
};
export default workerConstructor;
}
declare module '*?worker&inline' {
const workerConstructor: {
new (): Worker;
};
export default workerConstructor;
}
declare module '*?worker&url' {
const src: string;
export default src;
}
declare module '*?sharedworker' {
const sharedWorkerConstructor: {
new (): SharedWorker;
};
export default sharedWorkerConstructor;
}
declare module '*?sharedworker&inline' {
const sharedWorkerConstructor: {
new (): SharedWorker;
};
export default sharedWorkerConstructor;
}
declare module '*?sharedworker&url' {
const src: string;
export default src;
}
declare module '*?raw' {
const src: string;
export default src;
}
declare module '*?url' {
const src: string;
export default src;
}
declare module '*?inline' {
const src: string;
export default src;
}

41
packages/astro/client-image.d.ts vendored
View file

@ -1,41 +0,0 @@
/// <reference path="./client-base.d.ts" />
// TODO: Merge this file with `client-base.d.ts` in 3.0, when the `astro:assets` feature isn't under a flag anymore.
type InputFormat = import('./dist/assets/types.js').ImageInputFormat;
interface ImageMetadata {
src: string;
width: number;
height: number;
format: InputFormat;
}
declare module '*.gif' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.jpeg' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.jpg' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.png' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.tiff' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.webp' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.svg' {
const metadata: ImageMetadata;
export default metadata;
}

468
packages/astro/client.d.ts vendored
View file

@ -1,31 +1,465 @@
/// <reference path="./client-base.d.ts" />
/// <reference path="./import-meta.d.ts" />
// images
declare module '*.jpg' {
const src: string;
export default src;
// eslint-disable-next-line @typescript-eslint/no-namespace
declare namespace App {
// eslint-disable-next-line @typescript-eslint/no-empty-interface
export interface Locals {}
}
interface ImportMetaEnv {
/**
* The prefix for Astro-generated asset links if the build.assetsPrefix config option is set. This can be used to create asset links not handled by Astro.
*/
readonly ASSETS_PREFIX: string;
/**
* This is set to the site option specified in your project’s Astro config file.
*/
readonly SITE: string;
}
interface ImportMeta {
/**
* Astro and Vite expose environment variables through `import.meta.env`. For a complete list of the environment variables available, see the two references below.
*
* - [Astro reference](https://docs.astro.build/en/guides/environment-variables/#default-environment-variables)
* - [Vite reference](https://vitejs.dev/guide/env-and-mode.html#env-variables)
*/
readonly env: ImportMetaEnv;
}
declare module 'astro:assets' {
// Exporting things one by one is a bit cumbersome, not sure if there's a better way - erika, 2023-02-03
type AstroAssets = {
// getImage's type here is different from the internal function since the Vite module implicitly pass the service config
/**
* Get an optimized image and the necessary attributes to render it.
*
* **Example**
* ```astro
* ---
* import { getImage } from 'astro:assets';
* import originalImage from '../assets/image.png';
*
* const optimizedImage = await getImage({src: originalImage, width: 1280 });
* ---
* <img src={optimizedImage.src} {...optimizedImage.attributes} />
* ```
*
* This is functionally equivalent to using the `<Image />` component, as the component calls this function internally.
*/
getImage: (
options:
| import('./dist/assets/types.js').ImageTransform
| import('./dist/assets/types.js').UnresolvedImageTransform
) => Promise<import('./dist/assets/types.js').GetImageResult>;
getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
Image: typeof import('./components/Image.astro').default;
};
type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };
type ImgAttributes = WithRequired<
Omit<import('./types').HTMLAttributes<'img'>, 'src' | 'width' | 'height'>,
'alt'
>;
export type LocalImageProps = Simplify<
import('./dist/assets/types.js').LocalImageProps<ImgAttributes>
>;
export type RemoteImageProps = Simplify<
import('./dist/assets/types.js').RemoteImageProps<ImgAttributes>
>;
export const { getImage, getConfiguredImageService, Image }: AstroAssets;
}
type InputFormat = import('./dist/assets/types.js').ImageInputFormat;
interface ImageMetadata {
src: string;
width: number;
height: number;
format: InputFormat;
}
declare module '*.gif' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.jpeg' {
const src: string;
export default src;
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.jpg' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.png' {
const src: string;
export default src;
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.gif' {
const src: string;
export default src;
}
declare module '*.svg' {
const src: string;
export default src;
declare module '*.tiff' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.webp' {
const metadata: ImageMetadata;
export default metadata;
}
declare module '*.svg' {
const metadata: ImageMetadata;
export default metadata;
}
declare module 'astro:transitions' {
type TransitionModule = typeof import('./dist/transitions/index.js');
export const slide: TransitionModule['slide'];
export const fade: TransitionModule['fade'];
type ViewTransitionsModule = typeof import('./components/ViewTransitions.astro');
export const ViewTransitions: ViewTransitionsModule['default'];
}
type MD = import('./dist/@types/astro').MarkdownInstance<Record<string, any>>;
interface ExportedMarkdownModuleEntities {
frontmatter: MD['frontmatter'];
file: MD['file'];
url: MD['url'];
getHeadings: MD['getHeadings'];
/** @deprecated Renamed to `getHeadings()` */
getHeaders: () => void;
Content: MD['Content'];
rawContent: MD['rawContent'];
compiledContent: MD['compiledContent'];
load: MD['default'];
}
declare module '*.md' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.markdown' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mkdn' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mkd' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mdwn' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mdown' {
const { load }: ExportedMarkdownModuleEntities;
export const {
frontmatter,
file,
url,
getHeadings,
getHeaders,
Content,
rawContent,
compiledContent,
}: ExportedMarkdownModuleEntities;
export default load;
}
declare module '*.mdx' {
type MDX = import('./dist/@types/astro').MDXInstance<Record<string, any>>;
export const frontmatter: MDX['frontmatter'];
export const file: MDX['file'];
export const url: MDX['url'];
export const getHeadings: MDX['getHeadings'];
export const Content: MDX['Content'];
const load: MDX['default'];
export default load;
}
declare module 'astro:ssr-manifest' {
export const manifest: import('./dist/@types/astro').SSRManifest;
}
// Everything below are Vite's types (apart from image types, which are in `client.d.ts`)
// CSS modules
type CSSModuleClasses = { readonly [key: string]: string };
declare module '*.module.css' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.scss' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.sass' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.less' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.styl' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.stylus' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.pcss' {
const classes: CSSModuleClasses;
export default classes;
}
declare module '*.module.sss' {
const classes: CSSModuleClasses;
export default classes;
}
// CSS
declare module '*.css' {
const css: string;
export default css;
}
declare module '*.scss' {
const css: string;
export default css;
}
declare module '*.sass' {
const css: string;
export default css;
}
declare module '*.less' {
const css: string;
export default css;
}
declare module '*.styl' {
const css: string;
export default css;
}
declare module '*.stylus' {
const css: string;
export default css;
}
declare module '*.pcss' {
const css: string;
export default css;
}
declare module '*.sss' {
const css: string;
export default css;
}
// Built-in asset types
// see `src/node/constants.ts`
// images
declare module '*.jfif' {
const src: string;
export default src;
}
declare module '*.avif' {
declare module '*.pjpeg' {
const src: string;
export default src;
}
declare module '*.pjp' {
const src: string;
export default src;
}
declare module '*.ico' {
const src: string;
export default src;
}
// media
declare module '*.mp4' {
const src: string;
export default src;
}
declare module '*.webm' {
const src: string;
export default src;
}
declare module '*.ogg' {
const src: string;
export default src;
}
declare module '*.mp3' {
const src: string;
export default src;
}
declare module '*.wav' {
const src: string;
export default src;
}
declare module '*.flac' {
const src: string;
export default src;
}
declare module '*.aac' {
const src: string;
export default src;
}
declare module '*.opus' {
const src: string;
export default src;
}
// fonts
declare module '*.woff' {
const src: string;
export default src;
}
declare module '*.woff2' {
const src: string;
export default src;
}
declare module '*.eot' {
const src: string;
export default src;
}
declare module '*.ttf' {
const src: string;
export default src;
}
declare module '*.otf' {
const src: string;
export default src;
}
// other
declare module '*.webmanifest' {
const src: string;
export default src;
}
declare module '*.pdf' {
const src: string;
export default src;
}
declare module '*.txt' {
const src: string;
export default src;
}
// wasm?init
declare module '*.wasm?init' {
const initWasm: (options: WebAssembly.Imports) => Promise<WebAssembly.Instance>;
export default initWasm;
}
// web worker
declare module '*?worker' {
const workerConstructor: {
new (): Worker;
};
export default workerConstructor;
}
declare module '*?worker&inline' {
const workerConstructor: {
new (): Worker;
};
export default workerConstructor;
}
declare module '*?worker&url' {
const src: string;
export default src;
}
declare module '*?sharedworker' {
const sharedWorkerConstructor: {
new (): SharedWorker;
};
export default sharedWorkerConstructor;
}
declare module '*?sharedworker&inline' {
const sharedWorkerConstructor: {
new (): SharedWorker;
};
export default sharedWorkerConstructor;
}
declare module '*?sharedworker&url' {
const src: string;
export default src;
}
declare module '*?raw' {
const src: string;
export default src;
}
declare module '*?url' {
const src: string;
export default src;
}
declare module '*?inline' {
const src: string;
export default src;
}

1
packages/astro/e2e/fixtures/view-transitions/astro.config.mjs
View file

@ -9,7 +9,6 @@ export default defineConfig({
integrations: [react()],
experimental: {
viewTransitions: true,
assets: true,
},
vite: {
build: {

4
packages/astro/env.d.ts vendored
View file

@ -1,8 +1,8 @@
/// <reference path="./client-base.d.ts" />
/// <reference path="./client.d.ts" />
// Caution! The types here are only available inside Astro files (injected automatically by our language server)
// As such, if the typings you're trying to add should be available inside ex: React components, they should instead
// be inside `client-base.d.ts`
// be inside `client.d.ts`
type Astro = import('./dist/@types/astro.js').AstroGlobal;

4
packages/astro/package.json
View file

@ -34,8 +34,6 @@
"./env": "./env.d.ts",
"./types": "./types.d.ts",
"./client": "./client.d.ts",
"./client-base": "./client-base.d.ts",
"./client-image": "./client-image.d.ts",
"./import-meta": "./import-meta.d.ts",
"./astro-jsx": "./astro-jsx.d.ts",
"./tsconfigs/*.json": "./tsconfigs/*",
@ -91,8 +89,6 @@
"zod.mjs",
"env.d.ts",
"client.d.ts",
"client-base.d.ts",
"client-image.d.ts",
"content-types.template.d.ts",
"content-module.template.mjs",
"import-meta.d.ts",

22
packages/astro/src/@types/astro.ts
View file

@ -132,7 +132,6 @@ export interface CLIFlags {
config?: string;
drafts?: boolean;
open?: boolean;
experimentalAssets?: boolean;
}
/**
@ -1231,27 +1230,6 @@ export interface AstroUserConfig {
* These flags are not guaranteed to be stable.
*/
experimental?: {
/**
* @docs
* @name experimental.assets
* @type {boolean}
* @default `false`
* @version 2.1.0
* @description
* Enable experimental support for optimizing and resizing images. With this enabled, a new `astro:assets` module will be exposed.
*
* To enable this feature, set `experimental.assets` to `true` in your Astro config:
*
* ```js
* {
* experimental: {
* assets: true,
* },
* }
* ```
*/
assets?: boolean;
/**
* @docs
* @name experimental.viewTransitions

11
packages/astro/src/assets/image-endpoint.ts
View file

@ -1,11 +1,8 @@
import mime from 'mime/lite.js';
import type { APIRoute } from '../@types/astro.js';
import { isRemotePath } from '../core/path.js';
import { getConfiguredImageService } from './internal.js';
import { isLocalService } from './services/service.js';
import { etag } from './utils/etag.js';
// @ts-expect-error
import { imageServiceConfig } from 'astro:assets';
import { getConfiguredImageService, imageServiceConfig } from 'astro:assets';
async function loadRemoteImage(src: URL) {
try {
@ -28,7 +25,7 @@ export const GET: APIRoute = async ({ request }) => {
try {
const imageService = await getConfiguredImageService();
if (!isLocalService(imageService)) {
if (!('transform' in imageService)) {
throw new Error('Configured image service is not a local service');
}
@ -70,3 +67,7 @@ export const GET: APIRoute = async ({ request }) => {
return new Response(`Server Error: ${err}`, { status: 500 });
}
};
function isRemotePath(src: string) {
return /^(http|ftp|https|ws):?\/\//.test(src) || src.startsWith('data:');
}

1
packages/astro/src/assets/internal.ts
View file

@ -9,6 +9,7 @@ import type {
} from './types.js';
export function injectImageEndpoint(settings: AstroSettings) {
// TODO: Add a setting to disable the image endpoint
settings.injectedRoutes.push({
pattern: '/_image',
entryPoint: 'astro/assets/image-endpoint',

3
packages/astro/src/cli/flags.ts
View file

@ -23,9 +23,6 @@ export function flagsToAstroInlineConfig(flags: Flags): AstroInlineConfig {
typeof flags.host === 'string' || typeof flags.host === 'boolean' ? flags.host : undefined,
open: typeof flags.open === 'boolean' ? flags.open : undefined,
},
experimental: {
assets: typeof flags.experimentalAssets === 'boolean' ? flags.experimentalAssets : undefined,
},
};
}

3
packages/astro/src/content/types-generator.ts
View file

@ -155,8 +155,7 @@ export async function createContentTypesGenerator({
fileURLToPath(event.entry),
contentPaths,
contentEntryExts,
dataEntryExts,
settings.config.experimental.assets
dataEntryExts
);
if (fileType === 'ignored') {
return { shouldGenerateTypes: false };

15
packages/astro/src/content/utils.ts
View file

@ -93,8 +93,7 @@ export async function getEntryData(
_internal: EntryInternal;
},
collectionConfig: CollectionConfig,
pluginContext: PluginContext,
config: AstroConfig
pluginContext: PluginContext
) {
let data;
if (collectionConfig.type === 'data') {
@ -106,12 +105,6 @@ export async function getEntryData(
let schema = collectionConfig.schema;
if (typeof schema === 'function') {
if (!config.experimental.assets) {
throw new Error(
'The function shape for schema can only be used when `experimental.assets` is enabled.'
);
}
schema = schema({
image: createImage(pluginContext, entry._internal.filePath),
});
@ -250,9 +243,7 @@ export function getEntryType(
entryPath: string,
paths: Pick<ContentPaths, 'config' | 'contentDir'>,
contentFileExts: string[],
dataFileExts: string[],
// TODO: Unflag this when we're ready to release assets - erika, 2023-04-12
experimentalAssets = false
dataFileExts: string[]
): 'content' | 'data' | 'config' | 'ignored' | 'unsupported' {
const { ext, base } = path.parse(entryPath);
const fileUrl = pathToFileURL(entryPath);
@ -260,7 +251,7 @@ export function getEntryType(
if (
hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir) ||
isOnIgnoreList(base) ||
(experimentalAssets && isImageAsset(ext))
isImageAsset(ext)
) {
return 'ignored';
} else if (contentFileExts.includes(ext)) {

18
packages/astro/src/content/vite-plugin-content-imports.ts
View file

@ -131,13 +131,7 @@ export const _internal = {
configureServer(viteServer) {
viteServer.watcher.on('all', async (event, entry) => {
if (CHOKIDAR_MODIFIED_EVENTS.includes(event)) {
const entryType = getEntryType(
entry,
contentPaths,
contentEntryExts,
dataEntryExts,
settings.config.experimental.assets
);
const entryType = getEntryType(entry, contentPaths, contentEntryExts, dataEntryExts);
if (!COLLECTION_TYPES_TO_INVALIDATE_ON.includes(entryType)) return;
// The content config could depend on collection entries via `reference()`.
@ -194,7 +188,7 @@ type GetEntryModuleParams<TEntryType extends ContentEntryType | DataEntryType> =
async function getContentEntryModule(
params: GetEntryModuleParams<ContentEntryType>
): Promise<ContentEntryModule> {
const { fileId, contentDir, pluginContext, config } = params;
const { fileId, contentDir, pluginContext } = params;
const { collectionConfig, entryConfig, entry, rawContents, collection } =
await getEntryModuleBaseInfo(params);
@ -221,8 +215,7 @@ async function getContentEntryModule(
? await getEntryData(
{ id, collection, _internal, unvalidatedData },
collectionConfig,
pluginContext,
config
pluginContext
)
: unvalidatedData;
@ -241,7 +234,7 @@ async function getContentEntryModule(
async function getDataEntryModule(
params: GetEntryModuleParams<DataEntryType>
): Promise<DataEntryModule> {
const { fileId, contentDir, pluginContext, config } = params;
const { fileId, contentDir, pluginContext } = params;
const { collectionConfig, entryConfig, entry, rawContents, collection } =
await getEntryModuleBaseInfo(params);
@ -256,8 +249,7 @@ async function getDataEntryModule(
? await getEntryData(
{ id, collection, _internal, unvalidatedData },
collectionConfig,
pluginContext,
config
pluginContext
)
: unvalidatedData;

12
packages/astro/src/core/build/generate.ts
View file

@ -186,15 +186,13 @@ export async function generatePages(opts: StaticBuildOptions, internals: BuildIn
}
}
if (opts.settings.config.experimental.assets) {
info(opts.logging, null, `\n${bgGreen(black(` generating optimized images `))}`);
for (const imageData of getStaticImageList()) {
await generateImage(opts, imageData[1].options, imageData[1].path);
}
delete globalThis?.astroAsset?.addStaticImage;
info(opts.logging, null, `\n${bgGreen(black(` generating optimized images `))}`);
for (const imageData of getStaticImageList()) {
await generateImage(opts, imageData[1].options, imageData[1].path);
}
delete globalThis?.astroAsset?.addStaticImage;
await runHookBuildGenerated({
config: opts.settings.config,
logging: opts.logging,

4
packages/astro/src/core/build/index.ts
View file

@ -102,9 +102,7 @@ class AstroBuilder {
logging,
});
// HACK: Since we only inject the endpoint if `experimental.assets` is on and it's possible for an integration to
// add that flag, we need to only check and inject the endpoint after running the config setup hook.
if (this.settings.config.experimental.assets && isServerLikeOutput(this.settings.config)) {
if (isServerLikeOutput(this.settings.config)) {
this.settings = injectImageEndpoint(this.settings);
}

18
packages/astro/src/core/build/plugins/plugin-pages.ts
View file

@ -8,6 +8,7 @@ import type { StaticBuildOptions } from '../types';
import { MIDDLEWARE_MODULE_ID } from './plugin-middleware.js';
import { RENDERERS_MODULE_ID } from './plugin-renderers.js';
import { ASTRO_PAGE_EXTENSION_POST_PATTERN, getPathFromVirtualModulePageName } from './util.js';
import type { AstroSettings } from '../../../@types/astro';
export const ASTRO_PAGE_MODULE_ID = '@astro-page:';
export const ASTRO_PAGE_RESOLVED_MODULE_ID = '\0' + ASTRO_PAGE_MODULE_ID;
@ -74,11 +75,7 @@ function vitePluginPages(opts: StaticBuildOptions, internals: BuildInternals): V
exports.push(`export { renderers };`);
// The middleware should not be imported by the pages
if (
// TODO: remover in Astro 4.0
!opts.settings.config.build.excludeMiddleware ||
opts.settings.adapter?.adapterFeatures?.edgeMiddleware === true
) {
if (shouldBundleMiddleware(opts.settings)) {
const middlewareModule = await this.resolve(MIDDLEWARE_MODULE_ID);
if (middlewareModule) {
imports.push(`import { onRequest } from "${middlewareModule.id}";`);
@ -94,6 +91,17 @@ function vitePluginPages(opts: StaticBuildOptions, internals: BuildInternals): V
};
}
export function shouldBundleMiddleware(settings: AstroSettings) {
// TODO: Remove in Astro 4.0
if (settings.config.build.excludeMiddleware === true) {
return false;
}
if (settings.adapter?.adapterFeatures?.edgeMiddleware === true) {
return false;
}
return true;
}
export function pluginPages(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin {
return {
build: 'ssr',

2
packages/astro/src/core/build/plugins/plugin-prerender.ts
View file

@ -14,7 +14,7 @@ function vitePluginPrerender(opts: StaticBuildOptions, internals: BuildInternals
extendManualChunks(outputOptions, {
after(id, meta) {
// Split the Astro runtime into a separate chunk for readability
if (id.includes('astro/dist')) {
if (id.includes('astro/dist/runtime')) {
return 'astro';
}
const pageInfo = internals.pagesByViteID.get(id);

2
packages/astro/src/core/config/config.ts
View file

@ -124,8 +124,6 @@ export function resolveFlags(flags: Partial<Flags>): CLIFlags {
host:
typeof flags.host === 'string' || typeof flags.host === 'boolean' ? flags.host : undefined,
drafts: typeof flags.drafts === 'boolean' ? flags.drafts : undefined,
experimentalAssets:
typeof flags.experimentalAssets === 'boolean' ? flags.experimentalAssets : undefined,
};
}

2
packages/astro/src/core/config/schema.ts
View file

@ -44,7 +44,6 @@ const ASTRO_CONFIG_DEFAULTS = {
legacy: {},
redirects: {},
experimental: {
assets: false,
viewTransitions: false,
optimizeHoistedScript: false,
},
@ -241,7 +240,6 @@ export const AstroConfigSchema = z.object({
.default(ASTRO_CONFIG_DEFAULTS.vite),
experimental: z
.object({
assets: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.assets),
viewTransitions: z
.boolean()
.optional()

1
packages/astro/src/core/config/settings.ts
View file

@ -17,7 +17,6 @@ export function createBaseSettings(config: AstroConfig): AstroSettings {
config,
tsConfig: undefined,
tsConfigPath: undefined,
adapter: undefined,
injectedRoutes: [],
resolvedInjectedRoutes: [],

2
packages/astro/src/core/create-vite.ts
View file

@ -132,7 +132,7 @@ export async function createVite(
astroContentImportPlugin({ fs, settings }),
astroContentAssetPropagationPlugin({ mode, settings }),
vitePluginSSRManifest(),
settings.config.experimental.assets ? [astroAssetsPlugin({ settings, logging, mode })] : [],
astroAssetsPlugin({ settings, logging, mode }),
astroTransitions({ config: settings.config }),
],
publicDir: fileURLToPath(settings.config.publicDir),

6
packages/astro/src/core/dev/container.ts
View file

@ -50,11 +50,7 @@ export async function createContainer({
isRestart,
});
// HACK: Since we only inject the endpoint if `experimental.assets` is on and it's possible for an integration to
// add that flag, we need to only check and inject the endpoint after running the config setup hook.
if (settings.config.experimental.assets) {
settings = injectImageEndpoint(settings);
}
settings = injectImageEndpoint(settings);
const { host, headers, open } = settings.config.server;

7
packages/astro/src/core/routing/manifest/create.ts
View file

@ -185,7 +185,12 @@ function injectedRouteToItem(
{ config, cwd }: { config: AstroConfig; cwd?: string },
{ pattern, entryPoint }: InjectedRoute
): Item {
const resolved = require.resolve(entryPoint, { paths: [cwd || fileURLToPath(config.root)] });
let resolved: string;
try {
resolved = require.resolve(entryPoint, { paths: [cwd || fileURLToPath(config.root)] });
} catch (e) {
resolved = fileURLToPath(new URL(entryPoint, config.root));
}
const ext = path.extname(pattern);

26
packages/astro/src/vite-plugin-inject-env-ts/index.ts
View file

@ -50,26 +50,6 @@ export async function setUpEnvTs({
if (fs.existsSync(envTsPath)) {
let typesEnvContents = await fs.promises.readFile(envTsPath, 'utf-8');
// TODO: Remove this logic in 3.0, as `astro/client-image` will be merged into `astro/client`
if (settings.config.experimental.assets && typesEnvContents.includes('types="astro/client"')) {
typesEnvContents = typesEnvContents.replace(
'types="astro/client"',
'types="astro/client-image"'
);
await fs.promises.writeFile(envTsPath, typesEnvContents, 'utf-8');
info(logging, 'assets', `Added ${bold(envTsPathRelativetoRoot)} types`);
} else if (
!settings.config.experimental.assets &&
typesEnvContents.includes('types="astro/client-image"')
) {
typesEnvContents = typesEnvContents.replace(
'types="astro/client-image"',
'types="astro/client"'
);
await fs.promises.writeFile(envTsPath, typesEnvContents, 'utf-8');
info(logging, 'assets', `Removed ${bold(envTsPathRelativetoRoot)} types`);
}
if (!fs.existsSync(dotAstroDir))
// Add `.astro` types reference if none exists
return;
@ -83,11 +63,7 @@ export async function setUpEnvTs({
} else {
// Otherwise, inject the `env.d.ts` file
let referenceDefs: string[] = [];
if (settings.config.experimental.assets) {
referenceDefs.push('/// <reference types="astro/client-image" />');
} else {
referenceDefs.push('/// <reference types="astro/client" />');
}
referenceDefs.push('/// <reference types="astro/client" />');
if (fs.existsSync(dotAstroDir)) {
referenceDefs.push(dotAstroTypeReference);

5
packages/astro/src/vite-plugin-markdown/index.ts
View file

@ -75,7 +75,6 @@ export default function markdown({ settings, logging }: AstroPluginOptions): Plu
...settings.config.markdown,
fileURL: new URL(`file://${fileId}`),
frontmatter: raw.data,
experimentalAssets: settings.config.experimental.assets,
});
let html = renderResult.code;
@ -83,7 +82,7 @@ export default function markdown({ settings, logging }: AstroPluginOptions): Plu
// Resolve all the extracted images from the content
let imagePaths: { raw: string; resolved: string }[] = [];
if (settings.config.experimental.assets && renderResult.vfile.data.imagePaths) {
if (renderResult.vfile.data.imagePaths) {
for (let imagePath of renderResult.vfile.data.imagePaths.values()) {
imagePaths.push({
raw: imagePath,
@ -116,7 +115,7 @@ export default function markdown({ settings, logging }: AstroPluginOptions): Plu
import { AstroError, AstroErrorData } from ${JSON.stringify(astroErrorModulePath)};
${layout ? `import Layout from ${JSON.stringify(layout)};` : ''}
${settings.config.experimental.assets ? 'import { getImage } from "astro:assets";' : ''}
import { getImage } from "astro:assets";
export const images = {
${imagePaths.map(

21
packages/astro/test/core-image.test.js
View file

@ -20,9 +20,6 @@ describe('astro:image', () => {
before(async () => {
fixture = await loadFixture({
root: './fixtures/core-image/',
experimental: {
assets: true,
},
image: {
service: testImageService({ foo: 'bar' }),
},
@ -434,9 +431,6 @@ describe('astro:image', () => {
before(async () => {
fixture = await loadFixture({
root: './fixtures/core-image-errors/',
experimental: {
assets: true,
},
image: {
service: testImageService(),
},
@ -502,9 +496,6 @@ describe('astro:image', () => {
before(async () => {
fixture = await loadFixture({
root: './fixtures/core-image-base/',
experimental: {
assets: true,
},
image: {
service: testImageService(),
},
@ -558,9 +549,6 @@ describe('astro:image', () => {
root: './fixtures/core-image-ssr/',
output: 'server',
adapter: testAdapter(),
experimental: {
assets: true,
},
image: {
service: testImageService(),
},
@ -582,9 +570,6 @@ describe('astro:image', () => {
before(async () => {
fixture = await loadFixture({
root: './fixtures/core-image-ssg/',
experimental: {
assets: true,
},
image: {
service: testImageService(),
},
@ -748,9 +733,6 @@ describe('astro:image', () => {
root: './fixtures/core-image-ssr/',
output: 'server',
adapter: testAdapter(),
experimental: {
assets: true,
},
image: {
service: testImageService(),
},
@ -775,9 +757,6 @@ describe('astro:image', () => {
root: './fixtures/core-image-ssr/',
output: 'server',
adapter: testAdapter(),
experimental: {
assets: true,
},
image: {
service: testImageService(),
},

5
packages/astro/test/fixtures/astro-assets-prefix/astro.config.mjs vendored
View file

@ -1,5 +1,5 @@
import { defineConfig } from 'astro/config';
import react from '@astrojs/react';
import { defineConfig } from 'astro/config';
import { testImageService } from '../../test-image-service.js';
// https://astro.build/config
@ -10,9 +10,6 @@ export default defineConfig({
build: {
assetsPrefix: 'http://localhost:4321',
},
experimental: {
assets: true,
},
image: {
service: testImageService(),
},

4
packages/astro/test/fixtures/astro-assets/src/pages/index.astro vendored
View file

@ -9,7 +9,7 @@ import p2Url from '../images/penguin2.jpg?url';
</style>
<body>
<h1>Icons</h1>
<img src={(await import('../images/twitter.png')).default} srcset={`${(await import('../images/twitter.png')).default} 1x, ${(await import('../images/twitter@2x.png')).default} 2x, ${(await import('../images/twitter@3x.png')).default} 3x`} />
<img src={(await import('../images/twitter.png')).default.src} srcset={`${(await import('../images/twitter.png')).default.src} 1x, ${(await import('../images/twitter@2x.png')).default.src} 2x, ${(await import('../images/twitter@3x.png')).default.src} 3x`} />
<img srcset="https://ik.imagekit.io/demo/tr:w-300,h-300/medium_cafe_B1iTdD0C.jpg, https://ik.imagekit.io/demo/tr:w-450,h-450/medium_cafe_B1iTdD0C.jpg 600w, https://ik.imagekit.io/demo/tr:w-600,h-600/medium_cafe_B1iTdD0C.jpg 800w">
<img srcset="https://ik.imagekit.io/demo/tr:w-300,h-300/medium_cafe_B1iTdD0C.jpg, https://ik.imagekit.io/demo/tr:w-450,h-450/medium_cafe_B1iTdD0C.jpg 1.5x, https://ik.imagekit.io/demo/tr:w-600,h-600/medium_cafe_B1iTdD0C.jpg 2x">
<!--
@ -20,7 +20,7 @@ import p2Url from '../images/penguin2.jpg?url';
<source srcset="https://ik.imagekit.io/demo/tr:w-300,h-300/medium_cafe_B1iTdD0C.jpg, https://ik.imagekit.io/demo/tr:w-450,h-450/medium_cafe_B1iTdD0C.jpg 600w, https://ik.imagekit.io/demo/tr:w-600,h-600/medium_cafe_B1iTdD0C.jpg 800w">
</picture>
<img src={p1Url} id="import-no-url" />
<img src={p1Url.src} id="import-no-url" />
<img src={p2Url} id="import-url" />
</body>
</html>

3
packages/astro/test/fixtures/content-collection-references/astro.config.mjs vendored
View file

@ -3,9 +3,6 @@ import { testImageService } from '../../test-image-service.js';
// https://astro.build/config
export default defineConfig({
experimental: {
assets: true,
},
image: {
service: testImageService(),
},

2
packages/astro/test/ssr-split-manifest.test.js
View file

@ -43,7 +43,7 @@ describe('astro:ssr-manifest, split', () => {
it('should give access to entry points that exists on file system', async () => {
// number of the pages inside src/
expect(entryPoints.size).to.equal(5);
expect(entryPoints.size).to.equal(6);
for (const fileUrl of entryPoints.values()) {
let filePath = fileURLToPath(fileUrl);
expect(existsSync(filePath)).to.be.true;

21
packages/astro/test/units/content-collections/get-entry-type.test.js
View file

@ -28,14 +28,13 @@ const fixtures = [
const contentFileExts = ['.md', '.mdx'];
const dataFileExts = ['.yaml', '.yml', '.json'];
// TODO: Remove `getEntryType` last parameter once `experimental.assets` is no longer experimental
describe('Content Collections - getEntryType', () => {
fixtures.forEach(({ title, contentPaths }) => {
describe(title, () => {
it('Returns "content" for Markdown files', () => {
for (const entryPath of ['blog/first-post.md', 'blog/first-post.mdx']) {
const entry = fileURLToPath(new URL(entryPath, contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('content');
}
});
@ -47,7 +46,7 @@ describe('Content Collections - getEntryType', () => {
'banners/welcome.yml',
]) {
const entry = fileURLToPath(new URL(entryPath, contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('data');
}
});
@ -55,50 +54,50 @@ describe('Content Collections - getEntryType', () => {
it('Returns "content" for Markdown files in nested directories', () => {
for (const entryPath of ['blog/2021/01/01/index.md', 'blog/2021/01/01/index.mdx']) {
const entry = fileURLToPath(new URL(entryPath, contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('content');
}
});
it('Returns "config" for config files', () => {
const entry = fileURLToPath(contentPaths.config.url);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('config');
});
it('Returns "unsupported" for non-Markdown files', () => {
const entry = fileURLToPath(new URL('blog/robots.txt', contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('unsupported');
});
it('Returns "ignored" for .DS_Store', () => {
const entry = fileURLToPath(new URL('blog/.DS_Store', contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('ignored');
});
it('Returns "ignored" for unsupported files using an underscore', () => {
const entry = fileURLToPath(new URL('blog/_draft-robots.txt', contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('ignored');
});
it('Returns "ignored" when using underscore on file name', () => {
const entry = fileURLToPath(new URL('blog/_first-post.md', contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('ignored');
});
it('Returns "ignored" when using underscore on directory name', () => {
const entry = fileURLToPath(new URL('blog/_draft/first-post.md', contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, false);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('ignored');
});
it('Returns "ignored" for images', () => {
const entry = fileURLToPath(new URL('blog/first-post.png', contentPaths.contentDir));
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts, true);
const type = getEntryType(entry, contentPaths, contentFileExts, dataFileExts);
expect(type).to.equal('ignored');
});
});

4
packages/integrations/cloudflare/test/prerender.test.js
View file

@ -23,7 +23,7 @@ describe('Prerendering', () => {
expect(foundRoutes).to.deep.equal({
version: 1,
include: ['/'],
include: ['/', '/_image'],
exclude: [],
});
});
@ -51,7 +51,7 @@ describe('Hybrid rendering', () => {
expect(foundRoutes).to.deep.equal({
version: 1,
include: ['/one'],
include: ['/one', '/_image'],
exclude: [],
});
});

6
packages/integrations/cloudflare/test/routesJson.js
View file

@ -24,7 +24,7 @@ describe('_routes.json generation', () => {
expect(routes).to.deep.equal({
version: 1,
include: ['/a/*'],
include: ['/a/*', '/_image'],
exclude: ['/a/', '/a/redirect', '/a/index.html'],
});
});
@ -70,8 +70,8 @@ describe('_routes.json generation', () => {
expect(routes).to.deep.equal({
version: 1,
include: ['/'],
exclude: ['/'],
include: ['/_image'],
exclude: [],
});
});
});

2
packages/integrations/markdoc/package.json
View file

@ -34,7 +34,7 @@
".": "./dist/index.js",
"./components": "./components/index.ts",
"./runtime": "./dist/runtime.js",
"./experimental-assets-config": "./dist/experimental-assets-config.js",
"./runtime-assets-config": "./dist/runtime-assets-config.js",
"./package.json": "./package.json"
},
"typesVersions": {

26
packages/integrations/markdoc/src/content-entry-type.ts
View file

@ -1,6 +1,7 @@
import type { Config as MarkdocConfig, Node } from '@markdoc/markdoc';
import Markdoc from '@markdoc/markdoc';
import type { AstroConfig, ContentEntryType } from 'astro';
import { emitESMImage } from 'astro/assets/utils';
import matter from 'gray-matter';
import fs from 'node:fs';
import path from 'node:path';
@ -8,13 +9,12 @@ import { fileURLToPath } from 'node:url';
import type * as rollup from 'rollup';
import type { ErrorPayload as ViteErrorPayload } from 'vite';
import type { ComponentConfig } from './config.js';
import { MarkdocError, isComponentConfig, isValidUrl, prependForwardSlash } from './utils.js';
import { emitESMImage } from 'astro/assets/utils';
import { htmlTokenTransform } from './html/transform/html-token-transform.js';
import type { MarkdocConfigResult } from './load-config.js';
import type { MarkdocIntegrationOptions } from './options.js';
import { setupConfig } from './runtime.js';
import { getMarkdocTokenizer } from './tokenizer.js';
import { MarkdocError, isComponentConfig, isValidUrl, prependForwardSlash } from './utils.js';
export async function getContentEntryType({
markdocConfigResult,
@ -96,13 +96,11 @@ export async function getContentEntryType({
});
}
if (astroConfig.experimental.assets) {
await emitOptimizedImages(ast.children, {
astroConfig,
pluginContext,
filePath,
});
}
await emitOptimizedImages(ast.children, {
astroConfig,
pluginContext,
filePath,
});
const res = `import { Renderer } from '@astrojs/markdoc/components';
import { createGetHeadings, createContentComponent } from '@astrojs/markdoc/runtime';
@ -110,12 +108,10 @@ ${
markdocConfigUrl
? `import markdocConfig from ${JSON.stringify(markdocConfigUrl.pathname)};`
: 'const markdocConfig = {};'
}${
astroConfig.experimental.assets
? `\nimport { experimentalAssetsConfig } from '@astrojs/markdoc/experimental-assets-config';
markdocConfig.nodes = { ...experimentalAssetsConfig.nodes, ...markdocConfig.nodes };`
: ''
}
}
import { assetsConfig } from '@astrojs/markdoc/runtime-assets-config';
markdocConfig.nodes = { ...assetsConfig.nodes, ...markdocConfig.nodes };
${getStringifiedImports(componentConfigByTagMap, 'Tag', astroConfig.root)}
${getStringifiedImports(componentConfigByNodeMap, 'Node', astroConfig.root)}

5
packages/integrations/markdoc/src/experimental-assets-config.ts → packages/integrations/markdoc/src/runtime-assets-config.ts
View file

@ -3,10 +3,7 @@ import Markdoc from '@markdoc/markdoc';
//@ts-expect-error Cannot find module 'astro:assets' or its corresponding type declarations.
import { Image } from 'astro:assets';
// Separate module to only import `astro:assets` when
// `experimental.assets` flag is set in a project.
// TODO: merge with `./runtime.ts` when `experimental.assets` is baselined.
export const experimentalAssetsConfig: MarkdocConfig = {
export const assetsConfig: MarkdocConfig = {
nodes: {
image: {
attributes: {

3
packages/integrations/markdoc/src/runtime.ts
View file

@ -7,11 +7,10 @@ import Markdoc, {
} from '@markdoc/markdoc';
import type { AstroInstance } from 'astro';
import { createComponent, renderComponent } from 'astro/runtime/server/index.js';
import type { AstroMarkdocConfig } from './config.js';
import { type AstroMarkdocConfig } from './config.js';
import { setupHeadingConfig } from './heading-ids.js';
import { htmlTag } from './html/tagdefs/html.tag.js';
import type { MarkdocIntegrationOptions } from './options.js';
/**
* Merge user config with default config and set up context (ex. heading ID slugger)
* Called on each file's individual transform.

5
packages/integrations/markdoc/test/fixtures/image-assets/astro.config.mjs vendored
View file

@ -1,12 +1,9 @@
import { defineConfig } from 'astro/config';
import markdoc from '@astrojs/markdoc';
import { defineConfig } from 'astro/config';
import { testImageService } from '../../../../../astro/test/test-image-service.js';
// https://astro.build/config
export default defineConfig({
experimental: {
assets: true,
},
image: {
service: testImageService(),
},

2
packages/integrations/mdx/src/index.ts
View file

@ -80,7 +80,7 @@ export default function mdx(partialMdxOptions: Partial<MdxOptions> = {}): AstroI
});
const mdxPluginOpts: CompileOptions = {
remarkPlugins: await getRemarkPlugins(mdxOptions, config),
remarkPlugins: await getRemarkPlugins(mdxOptions),
rehypePlugins: getRehypePlugins(mdxOptions),
recmaPlugins: mdxOptions.recmaPlugins,
remarkRehypeOptions: mdxOptions.remarkRehype,

10
packages/integrations/mdx/src/plugins.ts
View file

@ -5,7 +5,6 @@ import {
} from '@astrojs/markdown-remark/dist/internal.js';
import { nodeTypes } from '@mdx-js/mdx';
import type { PluggableList } from '@mdx-js/mdx/lib/core.js';
import type { AstroConfig } from 'astro';
import type { Literal, MemberExpression } from 'estree';
import { visit as estreeVisit } from 'estree-util-visit';
import rehypeRaw from 'rehype-raw';
@ -96,13 +95,8 @@ export function rehypeApplyFrontmatterExport() {
};
}
export async function getRemarkPlugins(
mdxOptions: MdxOptions,
config: AstroConfig
): Promise<PluggableList> {
let remarkPlugins: PluggableList = [
...(config.experimental.assets ? [remarkCollectImages, remarkImageToComponent] : []),
];
export async function getRemarkPlugins(mdxOptions: MdxOptions): Promise<PluggableList> {
let remarkPlugins: PluggableList = [remarkCollectImages, remarkImageToComponent];
if (!isPerformanceBenchmark) {
if (mdxOptions.gfm) {

3
packages/integrations/mdx/test/fixtures/mdx-images/astro.config.ts vendored
View file

@ -3,9 +3,6 @@ import { testImageService } from '../../../../../astro/test/test-image-service.j
export default {
integrations: [mdx()],
experimental: {
assets: true,
},
image: {
service: testImageService(),
},

17
packages/integrations/netlify/test/functions/prerender.test.js
View file

@ -1,7 +1,7 @@
import { expect } from 'chai';
import { after } from 'node:test';
import netlifyAdapter from '../../dist/index.js';
import { loadFixture, testIntegration } from './test-utils.js';
import { after } from 'node:test';
describe('Mixed Prerendering with SSR', () => {
/** @type {import('./test-utils').Fixture} */
@ -27,9 +27,9 @@ describe('Mixed Prerendering with SSR', () => {
it('Wildcard 404 is sorted last', async () => {
const redir = await fixture.readFile('/_redirects');
const baseRouteIndex = redir.indexOf('/ /.netlify/functions/entry 200');
const oneRouteIndex = redir.indexOf('/one /one/index.html 200');
const fourOhFourWildCardIndex = redir.indexOf('/* /.netlify/functions/entry 404');
const baseRouteIndex = redir.indexOf('/ /.netlify/functions/entry 200');
const oneRouteIndex = redir.indexOf('/one /one/index.html 200');
const fourOhFourWildCardIndex = redir.indexOf('/* /.netlify/functions/entry 404');
expect(oneRouteIndex).to.not.be.equal(-1);
expect(fourOhFourWildCardIndex).to.be.greaterThan(baseRouteIndex);
@ -61,12 +61,15 @@ describe('Mixed Hybrid rendering with SSR', () => {
it('outputs a correct redirect file', async () => {
const redir = await fixture.readFile('/_redirects');
const baseRouteIndex = redir.indexOf('/one /.netlify/functions/entry 200');
const rootRouteIndex = redir.indexOf('/ /index.html 200');
const fourOhFourIndex = redir.indexOf('/404 /404.html 200');
console.log(redir);
const baseRouteIndex = redir.indexOf('/one /.netlify/functions/entry 200');
const rootRouteIndex = redir.indexOf('/ /index.html 200');
const fourOhFourIndex = redir.indexOf('/404 /404.html 200');
const imageEndpoint = redir.indexOf('/_image /.netlify/functions/entry 200');
expect(rootRouteIndex).to.not.be.equal(-1);
expect(baseRouteIndex).to.not.be.equal(-1);
expect(fourOhFourIndex).to.not.be.equal(-1);
expect(imageEndpoint).to.not.be.equal(-1);
});
});

8
packages/integrations/netlify/test/functions/redirects.test.js
View file

@ -1,6 +1,6 @@
import { expect } from 'chai';
import { loadFixture, testIntegration } from './test-utils.js';
import netlifyAdapter from '../../dist/index.js';
import { loadFixture, testIntegration } from './test-utils.js';
describe('SSG - Redirects', () => {
/** @type {import('../../../astro/test/test-utils').Fixture} */
@ -25,6 +25,7 @@ describe('SSG - Redirects', () => {
it('Creates a redirects file', async () => {
let redirects = await fixture.readFile('/_redirects');
let parts = redirects.split(/\s+/);
console.log(parts);
expect(parts).to.deep.equal([
'/other',
'/',
@ -38,6 +39,11 @@ describe('SSG - Redirects', () => {
'/.netlify/functions/entry',
'200',
// Image endpoint
'/_image',
'/.netlify/functions/entry',
'200',
// A real route
'/team/articles/*',
'/.netlify/functions/entry',

1
packages/integrations/netlify/test/functions/redirects.test.js.snap
View file

@ -4,5 +4,6 @@ exports[`SSG - Redirects Creates a redirects file 1`] = `
"/other / 301
/nope /.netlify/functions/entry 200
/ /.netlify/functions/entry 200
/_image /.netlify/functions/entry 200
/team/articles/* /.netlify/functions/entry 200"
`;

22
packages/integrations/netlify/test/functions/split-support.test.js
View file

@ -30,7 +30,7 @@ describe('Split support', () => {
it('outputs a correct redirect file', async () => {
const redir = await fixture.readFile('/_redirects');
const lines = redir.split(/[\r\n]+/);
expect(lines.length).to.equal(2);
expect(lines.length).to.equal(3);
expect(lines[0].includes('/blog')).to.be.true;
expect(lines[0].includes('blog.astro')).to.be.true;
@ -43,15 +43,17 @@ describe('Split support', () => {
describe('Should create multiple functions', () => {
it('and hit 200', async () => {
if (_entryPoints) {
for (const [, filePath] of _entryPoints) {
const { handler } = await import(filePath.toString());
const resp = await handler({
httpMethod: 'POST',
headers: {},
rawUrl: 'http://example.com/',
body: '{}',
});
expect(resp.statusCode).to.equal(200);
for (const [routeData, filePath] of _entryPoints) {
if (routeData.route !== '/_image') {
const { handler } = await import(filePath.toString());
const resp = await handler({
httpMethod: 'GET',
headers: {},
rawUrl: `http://example.com${routeData.route}`,
body: '{}',
});
expect(resp.statusCode).to.equal(200);
}
}
} else {
expect(false).to.be.true;

3
packages/integrations/netlify/test/hosted/hosted-astro-project/astro.config.mjs
View file

@ -5,7 +5,4 @@ import { defineConfig } from 'astro/config';
export default defineConfig({
output: 'server',
adapter: netlify(),
experimental: {
assets: true,
},
});

3
packages/integrations/node/test/image.test.js
View file

@ -13,9 +13,6 @@ describe.skip('Image endpoint', () => {
root: './fixtures/image/',
output: 'server',
adapter: nodejs({ mode: 'standalone' }),
experimental: {
assets: true,
},
});
await fixture.build();
devPreview = await fixture.preview();

11
packages/integrations/vercel/src/image/shared.ts
View file

@ -1,4 +1,4 @@
import type { AstroConfig, ImageMetadata, ImageQualityPreset, ImageTransform } from 'astro';
import type { ImageMetadata, ImageQualityPreset, ImageTransform } from 'astro';
export const defaultImageConfig: VercelImageConfig = {
sizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
@ -56,15 +56,6 @@ export const qualityTable: Record<ImageQualityPreset, number> = {
max: 100,
};
// TODO: Remove once Astro 3.0 is out and `experimental.assets` is no longer needed
export function throwIfAssetsNotEnabled(config: AstroConfig, imageService: boolean | undefined) {
if (!config.experimental.assets && imageService) {
throw new Error(
`Using the Vercel Image Optimization-powered image service requires \`experimental.assets\` to be enabled. See https://docs.astro.build/en/guides/assets/ for more information.`
);
}
}
export function getImageConfig(
images: boolean | undefined,
imagesConfig: VercelImageConfig | undefined,

8
packages/integrations/vercel/src/serverless/adapter.ts
View file

@ -3,12 +3,7 @@ import type { AstroAdapter, AstroConfig, AstroIntegration, RouteData } from 'ast
import glob from 'fast-glob';
import { basename } from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
import {
defaultImageConfig,
getImageConfig,
throwIfAssetsNotEnabled,
type VercelImageConfig,
} from '../image/shared.js';
import { defaultImageConfig, getImageConfig, type VercelImageConfig } from '../image/shared.js';
import { exposeEnv } from '../lib/env.js';
import { getVercelOutput, removeDir, writeJson } from '../lib/fs.js';
import { copyDependenciesToFunction } from '../lib/nft.js';
@ -135,7 +130,6 @@ export default function vercelServerless({
});
},
'astro:config:done': ({ setAdapter, config }) => {
throwIfAssetsNotEnabled(config, imageService);
setAdapter(getAdapter({ functionPerRoute, edgeMiddleware }));
_config = config;
buildTempFolder = config.build.server;

8
packages/integrations/vercel/src/static/adapter.ts
View file

@ -1,11 +1,6 @@
import type { AstroAdapter, AstroConfig, AstroIntegration } from 'astro';
import {
defaultImageConfig,
getImageConfig,
throwIfAssetsNotEnabled,
type VercelImageConfig,
} from '../image/shared.js';
import { defaultImageConfig, getImageConfig, type VercelImageConfig } from '../image/shared.js';
import { exposeEnv } from '../lib/env.js';
import { emptyDir, getVercelOutput, writeJson } from '../lib/fs.js';
import { isServerLikeOutput } from '../lib/prerender.js';
@ -52,7 +47,6 @@ export default function vercelStatic({
});
},
'astro:config:done': ({ setAdapter, config }) => {
throwIfAssetsNotEnabled(config, imageService);
setAdapter(getAdapter());
_config = config;

12
packages/integrations/vercel/test/edge-middleware.test.js
View file

@ -1,30 +1,32 @@
import { loadFixture } from './test-utils.js';
import { expect } from 'chai';
import chaiJestSnapshot from 'chai-jest-snapshot';
import { loadFixture } from './test-utils.js';
describe('Vercel edge middleware', () => {
it('with edge handle file, should successfully build the middleware', async () => {
// TODO: The path here seems to be inconsistent?
it.skip('with edge handle file, should successfully build the middleware', async () => {
const fixture = await loadFixture({
root: './fixtures/middleware-with-edge-file/',
});
await fixture.build();
const contents = await fixture.readFile(
// this is abysmal...
'../.vercel/output/functions/render.func/packages/integrations/vercel/test/fixtures/middleware-with-edge-file/dist/middleware.mjs'
'../.vercel/output/functions/render.func/www/withastro/astro/packages/integrations/vercel/test/fixtures/middleware-with-edge-file/dist/middleware.mjs'
);
expect(contents.includes('title:')).to.be.true;
chaiJestSnapshot.setTestName('Middleware with handler file');
expect(contents).to.matchSnapshot(true);
});
it('with edge handle file, should successfully build the middleware', async () => {
// TODO: The path here seems to be inconsistent?
it.skip('with edge handle file, should successfully build the middleware', async () => {
const fixture = await loadFixture({
root: './fixtures/middleware-without-edge-file/',
});
await fixture.build();
const contents = await fixture.readFile(
// this is abysmal...
'../.vercel/output/functions/render.func/packages/integrations/vercel/test/fixtures/middleware-without-edge-file/dist/middleware.mjs'
'../.vercel/output/functions/render.func/www/withastro/astro/packages/integrations/vercel/test/fixtures/middleware-without-edge-file/dist/middleware.mjs'
);
expect(contents.includes('title:')).to.be.false;
chaiJestSnapshot.setTestName('Middleware without handler file');

3
packages/integrations/vercel/test/fixtures/image/astro.config.mjs vendored
View file

@ -4,9 +4,6 @@ import { testImageService } from '../../../../../astro/test/test-image-service.j
export default defineConfig({
adapter: vercel({imageService: true}),
experimental: {
assets: true,
},
image: {
service: testImageService(),
},

3
packages/integrations/vercel/test/hosted/hosted-astro-project/astro.config.mjs
View file

@ -5,7 +5,4 @@ import { defineConfig } from 'astro/config';
export default defineConfig({
output: 'server',
adapter: vercel(),
experimental: {
assets: true,
},
});

5
packages/integrations/vercel/test/serverless-prerender.test.js
View file

@ -17,10 +17,11 @@ describe('Serverless prerender', () => {
expect(await fixture.readFile('../.vercel/output/static/index.html')).to.be.ok;
});
it('includeFiles work', async () => {
// TODO: The path here seems to be inconsistent?
it.skip('includeFiles work', async () => {
expect(
await fixture.readFile(
'../.vercel/output/functions/render.func/packages/integrations/vercel/test/fixtures/serverless-prerender/included.js'
'../.vercel/output/functions/render.func/packages/integrations/vercel/test/fixtures/serverless-prerender/dist/middleware.mjs'
)
).to.be.ok;
});

4
packages/integrations/vercel/test/split.test.js
View file

@ -15,12 +15,12 @@ describe('build: split', () => {
it('creates separate functions for each page', async () => {
const files = await fixture.readdir('../.vercel/output/functions/');
expect(files.length).to.equal(2);
expect(files.length).to.equal(3);
});
it('creates the route definitions in the config.json', async () => {
const json = await fixture.readFile('../.vercel/output/config.json');
const config = JSON.parse(json);
expect(config.routes).to.have.a.lengthOf(4);
expect(config.routes).to.have.a.lengthOf(5);
});
});

10
packages/markdown/remark/src/index.ts
View file

@ -95,10 +95,8 @@ export async function renderMarkdown(
parser.use([remarkPrism(scopedClassName)]);
}
if (opts.experimentalAssets) {
// Apply later in case user plugins resolve relative image paths
parser.use([remarkCollectImages]);
}
// Apply later in case user plugins resolve relative image paths
parser.use([remarkCollectImages]);
}
parser.use([
@ -116,9 +114,7 @@ export async function renderMarkdown(
parser.use([[plugin, pluginOpts]]);
});
if (opts.experimentalAssets) {
parser.use(rehypeImages());
}
parser.use(rehypeImages());
if (!isPerformanceBenchmark) {
parser.use([rehypeHeadingIds]);
}

1
packages/markdown/remark/src/types.ts
View file

@ -67,7 +67,6 @@ export interface MarkdownRenderingOptions extends AstroMarkdownOptions {
};
/** Used for frontmatter injection plugins */
frontmatter?: Record<string, any>;
experimentalAssets?: boolean;
}
export interface MarkdownHeading {