Astro Picture Component: adding Responsive Images 🖼️ # Astro Picture Component: adding Responsive Images 🖼️ #

😕 The Astro Picture Component #

The HTML <picture> tag, essentially, is a way of communicating to the browser which formats you have available on the server and in what sizes, and letting the browser pick the most suitable one. You can imagine, adding this much detail for each image can become cumbersome. And we haven’t even mentioned adding markup to prevent Cumulative Layout Shift (CLS) yet!

The Astro Picture component is designed to help you here, saving you from having to construct that HTML <picture> tag yourself. In this post, we see how you can work with the Astro Picture component to add a banner image to each post on a blog site. As a bonus, we also look at using Astro Content Collections, to generate a low-resolution placeholder image to display while the banner image is loading.

🧱 What are we Building? #

Instead of building a new blog from start-to-finish, we’ll just see the steps you need to add banner images to blog posts to an existing Astro Markdown site with Content Collections  . There is a link to the complete project code further down the page.

👮🏽 Content Collections #

Content collections are invaluable for making sure your content Markdown front matter has all the fields you need it to have. The schema uses zod under the hood  , so you might already be familiar with the syntax. Here, we will see how you can also use the schema to generate the image metadata needed for use with Astro’s Picture component.

    
1 ---
2 postTitle: 'Best Medium Format Camera for Starting Out'
3 datePublished: '2023-10-07T16:04:42.000+0100'
4 lastUpdated: '2022-10-23T10:17:52.000+0100'
5 featuredImage: './best-medium-format-camera-for-starting-out.jpg'
6 featuredImageAlt: 'Photograph of a Hasselblad medium format camera with the focusing screen exposed'
7 ---
8 
9 ## What is a Medium Format Camera?
10 
11 If you are old enough to remember the analogue film camera era, chances are it is the 35 mm canisters with the track cut down the side that first come to mind. Shots normally...

  

The first step is to place the banner image in the content folder, within your Astro project. Here, I copied the image I want to use to the same directory as the Markdown file containing the post content.

Then, above, you can see I added a featuredImage field to the post front matter, with the path to the image (path is relative to the Markdown file’s own path, src/content/posts/best-medium-format-camera-for-starting-out/index.md). Equally important is the image alt text (in line 6), which we also want to feed into the Astro Picture component.

Schema File #

The next change is to the schema file (at src/content/config.ts). A schema is not required for using Content Collections generally, though you will need one to generate the image meta. See zod docs for explanation of anything that you are not familiar with, or drop a question below in the comments.

    
1 import { defineCollection, z } from 'astro:content';
2 
3 const postsCollection = defineCollection({
4 	type: 'content',
5 	schema: ({ image }) =>
6 		z.object({
7 			postTitle: z.string(),
8 			datePublished: z.string(),
9 			lastUpdated: z.string(),
10 			featuredImage: image(),
11 			featuredImageAlt: z.string(),
12 			ogImage: z.string().optional(),
13 			draft: z.boolean(),
14 		}),
15 });
16 
17 export const collections = {
18 	posts: postsCollection,
19 };

  

For Astro to generate the image metadata, just include the image function as an argument to the callback in line 5, and call that same function on the featuredImage field. If you include multiple image fields in the front matter, you can call image on each.

Calling image automatically generates the following fields for the picture, which we use in the next section:

    
const featuredImage: {
    src: string;
    width: number;
    height: number;
    format: "png" | "jpg" | "jpeg" | "tiff" | "webp" | "gif" | "svg" | "avif";
}

  

🧩 Adding the Astro Picture Component #

The final missing piece of the puzzle is pulling in the metadata generated in the schema to an instance of the Astro Picture component. The first step, then, is to extract that metadata within the front matter section of the blog post page template (src/pages/[slug].astro):

    
1 ---
2 import { Picture } from 'astro:assets';
3 import type { CollectionEntry } from 'astro:content';
4 import { getCollection } from 'astro:content';
5 import BaseLayout from '~layouts/BaseLayout.astro';
6 
7 export async function getStaticPaths() {
8 	const posts = await getCollection('posts');
9 	return posts.map(
10 		({
11 			data: { featuredImage, featuredImageAlt, postTitle },
12 			render,
13 			slug,
14 		}) => {
15 			return {
16 				params: { slug },
17 				props: {
18 					featuredImage,
19 					featuredImageAlt,
20 					render,
21 					postTitle,
22 				},
23 			};
24 		},
25 	);
26 }
27 
28 type PostCollection = CollectionEntry<'posts'>;
29 type Props = Pick<
30 	PostCollection['data'],
31 	'featuredImage' | 'featuredImageAlt' | 'seoMetaDescription' | 'placeholder' | 'postTitle'
32 > &
33 	Pick<PostCollection, 'render'>;
34 
35 const { slug } = Astro.params;
36 const {
37 	featuredImage,
38 	featuredImageAlt,
39 	render,
40 	postTitle: title,
41 }: Props = Astro.props;
42 
43 const { Content } = await render();
44 
45 const { format, width, height } = featuredImage;
46 ---

  

Adding the Picture Component to Astro Markup #

To finish off, let’s add the Astro Picture component to the markup:

    
53 ---
54 // TRUNCATED...
55 ---
56 
57 <BaseLayout {...seoProps}>
58 	<h1>{title}</h1>
59 	<div class="image-wrapper">
60 		<Picture
61 			src={featuredImage}
62 			alt={featuredImageAlt}
63 			densities={[1.5, 2]}
64 			formats={['avif', 'webp']}
65 			fallbackFormat={format}
66 			loading="eager"
67 			fetchpriority="high"
68 		/>
69 	</div>
70 
71 	<div class="container">
72 		<Content />
73 	</div>
74 </BaseLayout>

  

• We imported the Picture from astro:assets in line 2 of the front matter.
• The component has the attributes you expect on a regular HTML img tag, such as src, alt and loading.
• For most images, loading will be lazy, to optimize page load. Generally, though, for a banner image or other large contentful object initially displayed, you will pick eager  , and also, to set fetchpriority to high.

Notice, we also have densities, formats and fallbackFormat props. These are used to generate the final HTML <picture> tag.

• densities are the pixel densities used for high resolution screens, like Retina displays, typically 1.5 and 2 will be just fine here.
• formats are the next-gen formats you want the images available in. To be safe, you might choose just webp as there have been issues with displaying some avif images in Safari  . An alternative is to use content negotiation  .
• fallbackFormat this is the format you want older browsers to use (browsers which do not support WebP or AVIF), and is probably the format of the original image.

Generated HTML Markup #

Using the above parameters, the final markup looks something like this:

    
<picture
  ><source
    srcset="
      /_astro/best-medium-format-camera-for-starting-out.8696310b_Zzixeg.avif,
      /_astro/best-medium-format-camera-for-starting-out.8696310b_Zzixeg.avif 1.5x,
      /_astro/best-medium-format-camera-for-starting-out.8696310b_Zzixeg.avif 2x
    "
    type="image/avif" />
  <source
    srcset="
      /_astro/best-medium-format-camera-for-starting-out.8696310b_Oo3Ed.webp,
      /_astro/best-medium-format-camera-for-starting-out.8696310b_Oo3Ed.webp 1.5x,
      /_astro/best-medium-format-camera-for-starting-out.8696310b_Oo3Ed.webp 2x
    "
    type="image/webp" />
  <img
    src="/_astro/best-medium-format-camera-for-starting-out.8696310b_1MPGLA.jpg"
    srcset="
      /_astro/best-medium-format-camera-for-starting-out.8696310b_1MPGLA.jpg 1.5x,
      /_astro/best-medium-format-camera-for-starting-out.8696310b_1MPGLA.jpg 2x
    "
    alt="Photograph of a Hasselblad medium format camera with the focusing screen exposed"
    loading="eager"
    data-astro-cid-yvbahnfj=""
    width="1344"
    height="896"
    decoding="async"
/></picture>

  

Notice the image URLs include a hash in the path, which is ideal for cache-busting.

🏆 Level it up: Low Resolution Placeholder #

You might not have known it is possible to transform front matter fields within the Content Collection schema file. We can use this feature to generate low resolution placeholders automatically, using the ThumbHash algorithm  .

To start, let’s add a placeholder field to the front matter:

    
1 ---
2 postTitle: 'Best Medium Format Camera for Starting Out'
3 datePublished: '2023-10-07T16:04:42.000+0100'
4 lastUpdated: '2022-10-23T10:17:52.000+0100'
5 featuredImage: './best-medium-format-camera-for-starting-out.jpg'
6 featuredImageAlt: 'Photograph of a Hasselblad medium format camera with the focusing screen exposed'
7 placeholder: 'best-medium-format-camera-for-starting-out/best-medium-format-camera-for-starting-out.jpg'
8 ---

  

To avoid using undocumented Astro APIs (which might later change), I have included the post folder name in the path here. This is different to how we added the featured image itself.

Next, we can add the transformation to our schema (src/content/config.ts):

    
1 import { image_placeholder } from '@rodneylab/picpack';
2 import { defineCollection, z } from 'astro:content';
3 import { readFile } from 'node:fs/promises';
4 
5 const postsCollection = defineCollection({
6 	type: 'content',
7 	schema: ({ image }) =>
8 		z.object({
9 			postTitle: z.string(),
10 			datePublished: z.string(),
11 			lastUpdated: z.string(),
12 			featuredImage: image(),
13 			featuredImageAlt: z.string(),
14 			ogImage: z.string().optional(),
15 			placeholder: z.string().transform(async (value) => {
16 				const { buffer } = await readFile(`./src/content/posts/${value}`);
17 				const imageBytes = new Uint8Array(buffer);
18 				const { base64 } = image_placeholder(imageBytes);
19 				return base64;
20 			}),
21 			draft: z.boolean(),
22 		}),
23 });
24 
25 export const collections = {
26 	posts: postsCollection,
27 };

  

Here, I added a Rust WASM helper package (@rodneylab/picpack  ) to generate the placeholder using ThumbHash. The arrow function in the placeholder field (lines 15 – 19) reads the bytes from the image and generates a Base64-encoded placeholder. We took the image path and transformed the field to make a placeholder Base64-encoded string available in the Astro page template.

Placeholder Markup #

    
53 ---
54 // TRUNCATED...
55 ---
56 
57 <BaseLayout {...seoProps}>
58 	<h1>{title}</h1>
59 	<div class="image-wrapper">
60 		<img class="placeholder" aria-hidden="true" src={placeholder} width={width} height={height} />
61 		<Picture
62 			pictureAttributes={{ class: 'image lazy' }}
63 			src={featuredImage}
64 			alt={featuredImageAlt}
65 			densities={[1.5, 2]}
66 			formats={['avif', 'webp']}
67 			fallbackFormat={format}
68 			loading="eager"
69 			fetchpriority="high"
70 		/>
71 	</div>
72 
73 	<div class="container">
74 		<Content />
75 	</div>
76 </BaseLayout>

  

We have an extra <img> element, which will contain the placeholder. Its src is the Base64 placeholder, which we just generated in the schema transformation. Notice in line 60, the pictureAttributes prop lets us add a class to the generated <picture> tag.

The final missing piece is a spot of CSS to place the full-scale image on top of the placeholder, so that it displays (over the placeholder) as soon as it loads:

    
1 img,
2 picture {
3 	display: block;
4 	max-width: 100%;
5 	height: auto;
6 }
7 
8 .image-wrapper {
9 	display: grid;
10 
11 	.placeholder,
12 	.image {
13 		display: block;
14 		grid-area: 1/1/1/1;
15 		height: auto;
16 		aspect-ratio: 3/2;
17 	}
18 }

  

You can go to town on this, adding a touch of JavaScript to blend the placeholder into the full-scale image once it is loaded, though we won’t get into that here.

Astro Picture Component Alternatives #

Hopefully, this has given you an idea of how the Astro Picture component works, and whether it will be suitable for your own project. You might also consider the unpic project as an alternative  . It is designed to work with hosting services (such as Imgix), and has an Astro-specific image component.

You can also roll your own. The sharp image plugin  is a good starting point. It is performant, and runs in environments other than Node.js: Deno and Bun, for example.

🙌🏽 Astro Picture Component: Wrapping Up #

In this post, we saw how you can add responsive banner images to your Astro blog Markdown posts. In particular, we saw:

• how you can automatically generate image metadata using Content Collection schema;
• how you can transform front matter fields to generate Base64 placeholder images from image paths; and
• some options available on the Picture element to control the generation of next-gen AVIF and WebP alternatives for devices of different display sizes.

You can see the full code for this project in the Rodney Lab GitHub repo  . I do hope you have found this post useful! Let me know how you add pictures to your site, whether you use the Astro Picture components, go for unpic with a hosting service or build something more manual. Also, let me know about any possible improvements to the content above.

🙏🏽 Astro Picture Component: Feedback #

Have you found the post useful? Would you prefer to see posts on another topic instead? Get in touch with ideas for new posts. Also, if you like my writing style, get in touch if I can write some posts for your company site on a consultancy basis. Read on to find ways to get in touch, further below. If you want to support posts similar to this one and can spare a few dollars, euros or pounds, please consider supporting me through Buy me a Coffee.

Rodney

@askRodney

Just dropped a new post on using the new Astro Picture component.

You use:
— Astro Markdown APIs;
— Content Collection schema to generate a Base64 placeholder with ThumbHash; and
— the responsive Astro Picture component.

Hope you find it useful!

https://t.co/5O8SgVyYJj

— Rodney (@askRodney) November 6, 2023

Finally, feel free to share the post on your social media accounts for all your followers who will find it useful. As well as leaving a comment below, you can get in touch via @askRodney on X, @rodney@toot.community  on Mastodon and also the #rodney  Element Matrix room. Also, see further ways to get in touch with Rodney Lab. I post regularly on Astro as well as SEO. Also, subscribe to the newsletter to keep up-to-date with our latest projects.