Skip to content

Lookbook Reader and Long Look Lists

Status: built, November 2026. This records two changes to the shoppable image block: the options weighed, what a mock-up and its testing showed, what was decided, and what the build had to handle. The block's behaviour as shipped is in Shoppable images.

Terms used here:

  • Look: one shoppable image placed on a page: a photo, its pins and its list of pieces.
  • Piece: one product in a look (a coat, a pair of jeans).
  • Pin: the marker on the photo for a piece (a "hotspot" in the code).
  • Lookbook: a page made mostly of looks, one after another, like the Ashgrove demo's /p/lookbook (18 looks, 61 pieces, Atelier theme).
  • Reader: the proposed full-screen view of a lookbook, one look at a time.

The problem

Two things go wrong on a lookbook today.

  1. There is no way to read it like a magazine. Each look is a block in a long page, with the photo in a 7fr column beside its list. The photos are the point of the page, but none of them can be seen large, and there is no "next look" except scrolling.
  2. Long lists outgrow the photo. Each piece row carries a size select and an Add button, so a row is about 150px tall. Most looks have 2 to 4 pieces and balance their photo, but a group shot does not: "Out together" (four people, 12 pieces) runs to about 2,000px of list beside a 480px sticky photo, and a 15-piece look reaches about 2,500px. 17 of the 18 lookbook photos are landscape, so the photo column is short and the list beside it is the wrong shape anyway.

Goals for both changes: the photo comes first; buying stays one step away (size and Add to basket without leaving the look); a long list stays short and scannable; every link to a look keeps working with Back, shared links and no JavaScript; and the usual storefront rules hold (message keys, no inline styles, colours as tokens, public component tokens, no Bootstrap JS).

What other shops do (research, November 2026)

Observed on the live sites of several fashion retailers, at desktop and phone widths, plus published usability research (Baymard Institute, Nielsen Norman Group):

  • Nobody we looked at puts visible pins on editorial photos. COS, Arket and Zara keep the photo clean and put the products in a corner card, a "+" button or a drawer. Lighting a pin when its piece is hovered, as proposed here, is something none of them do.
  • No-one ships a true full-screen, swipeable lookbook on the web. The nearest is COS's runway page: an in-page expanded view with a rail of other looks and a side drawer of the pieces. On a phone it shows a strip of packshots under the photo and one tall bottom sheet for the size.
  • Size is chosen after the piece, never per row. Lists show thumbnail, name and price; the size grid (sold-out sizes greyed) appears once a piece is picked. Zara keeps sold-out items in place, labelled.
  • None of them change the URL when a look, drawer or sheet opens, so Back leaves the page. Baymard found that users expect Back to close an overlay, and that over a third of sites fail this; it also warns against adding a history entry per image.
  • Magazine-style lookbooks (Zara's editorials, Massimo Dutti) put chapter headings and short text between photos, from the page order.
  • Research on moving content: content that moves by itself takes control away, interrupts reading and hurts people with motor difficulties. Horizontal strips hide off-screen items on desktop, so something must help a mouse user reach them.

A. The reader

Structure

Options considered:

  • Build on PhotoSwipe, the image viewer the product gallery already loads. Rejected; see Assumptions tested.
  • A native <dialog> holding a CSS scroll-snap track (chosen). The dialog is opened with showModal(), which puts it in the browser's top layer (drawn above everything, whatever its z-index), moves focus in and makes the page behind inert (unreachable by Tab, pointer or screen reader). The track is a horizontal scroller with scroll-snap-type: x mandatory and scroll-snap-stop: always on each slide, so a hard flick moves one look, not three. Nova already has this pattern in blog-photowall.js, the blog's photo viewer.

The reader is built from the page, in page order: each shoppable image becomes a photo slide, and each text block between shoppable images becomes a text page (a cover, the introduction, a chapter opener). No new data model is needed: a shop adds a chapter by placing a text block between two looks in the same slot. The pieces reuse the page's own data rather than cloned forms, which would duplicate ids and the CSRF field.

On a wide screen the photo fills the screen (object-fit: contain on the paper or ink backdrop) with its pins hidden; a top bar holds Close, a counter ("4 / 18", announced politely) and Zoom; Previous and Next sit at the sides; a slim strip along the bottom lists the pieces (thumbnail, name, price). Hovering or focusing a piece lights its pin. Choosing a piece opens a size panel inside the reader.

Options considered: Back closes the reader, or Back steps back one look at a time. Both were built in the mock-up. Decided: Back steps back one look at a time, and the close button (X) closes.

  • Opening pushes a history entry, and so does each look or text page the shopper moves to. Back goes to the previous look; from the look the reader was opened at, Back closes it.
  • Close (X) and Escape close the reader in one go, going back by however many entries the reader added, and leave the page at the look the reader ended on.
  • The phone's pieces sheet and zoom each add one more entry, so Back leaves them before it changes look.
  • While reading, the URL is a plain #look-<handle> (a chapter page #chapter-<key>), set with history.pushState, never by assigning location.hash, which would scroll the page and fire extra events.
  • A shared link only scrolls. Copying the URL in the reader gives a link that opens the page scrolled to that look, with or without JavaScript, as #look- links do today. Nothing opens the reader from the URL; each look has its own way in instead (see Starting the reader).
  • The code listens for popstate and guards against closing twice: on Android the dialog closes on the back gesture and the history entry pops.

Starting the reader

Every look on the page can start the reader at that look: a "Full screen" button on the photo (keyboard reachable) and a click on the photo itself. The introduction has "Read the lookbook", which starts at the cover.

Zoom

Pinch inside a scroll-snap track is unreliable (the snap fights two-finger gestures and a pinch on a fixed dialog zooms the whole viewport), so the track allows panning only and zoom is a separate mode. The zoom button, a double-tap, or a pinch outwards opens that photo at about 2.5 times its size in a scrollable layer, centred on the tap; panning is ordinary scrolling. If that feels poor on real phones, the fallback is to load PhotoSwipe lazily for the one zoomed photo, mounted inside the dialog, where its pinch handling is at its best.

Text pages

Text pages are real markup in the track, so their text can be selected and their links work. The mock-up had a cover (title over one photo), the existing introduction, and chapter openers (an eyebrow, the chapter name in the display face, one line). The counter numbers looks only; a text page shows its chapter name instead. Ashgrove has no text blocks between looks today: its introduction is in another slot, so chapters need new blocks and a re-ordered page.

Phones

  • The photo fills the screen. On a portrait phone a landscape photo is cropped at its focal point, centred on screen and clamped so the crop never runs past the photo's edge, but only if every pin stays inside the crop (with a small margin); otherwise the photo is shown whole. Pins and zoom use the same offsets. This needs no "group shot" setting: a crop of "Out together" would hide 7 of its 12 pins, so the rule shows it whole, while a single model's photo is cropped.
  • Swipe between looks, with a gutter so an edge swipe isn't taken as the browser's Back.
  • Pins on touch screens. Pins are hidden, and a hidden pin takes no taps. When the reader opens on a photo its pins show for about 1.5 seconds, then fade, so the shopper learns they are there; this is not repeated on later looks. A tap on the photo shows the pins and the controls together, and both fade after about 3 seconds without a touch; a tap on a showing pin opens its piece, and a second tap on the photo hides everything at once. Choosing a piece in the pieces sheet lights its pin. Under prefers-reduced-motion they switch without fading. (A touch that moves under about 10px in under about 300ms counts as a tap.) Showing the pins on every look and fading them was rejected: it is noisy after the second look and easy to miss mid-swipe.
  • The strip becomes an "n pieces" button that opens one bottom sheet: the list first, then the size choice in the same sheet with an "All pieces" button back, never a second sheet on top. The sheet has a visible Close and clears the home indicator (env(safe-area-inset-bottom) plus 12px). Coming back to the list keeps its scroll position and the piece in view.

Keyboard and focus

Focus goes to the current slide on open and back to what opened it on close (or to the "Full screen" button of the look the reader ended on). Left and Right change look only when focus is not in a form control; inside the size grid they move between sizes, and Up and Down move a row of the grid. Escape closes the innermost layer first (zoom, then the panel or sheet, then the reader), using the dialog's cancel event. Over the strip, a vertical mouse wheel scrolls it sideways while it can still move, an edge fade shows which end has more, and a piece that takes focus is scrolled into view. If focus is on a slide when paging settles, it moves to the new slide.

B. Long lists beside a look

Three options, mocked together and separately:

  • B1, compact rows. About 72px a row: thumbnail, name, colourway, price and an Add button. Add opens a size popover: tapping a size adds it. Rows keep their height, so a 12-piece list drops from about 2,000px to 880px, and 15 pieces from 2,500px to 1,100px. The popover measures itself and opens below its button if it fits, otherwise above, never covering the button; it follows its row as the page scrolls and closes when the row leaves the screen. An inline row that expands was the alternative; it moves everything under it.
  • B2, layout follows the photo's shape. A portrait photo keeps its list beside it on a wide screen, as compact rows. A landscape photo runs full width with a horizontal strip of compact cards under it.
  • B3, the phone strip. Under 1024px every look uses the strip under the photo. Tapping a pin scrolls the strip (only the strip, not the page) to its card.

Strip cards put the name on top. A 272px card left the name about 86px, so names were cut to a few letters. Each card now has the name across its full width at the top (two lines, then an ellipsis, with two lines always reserved so a strip lines up), and one row underneath: number, thumbnail, colourway over price, and Add. The name link still covers the card, with Add and the thumbnail above it. The card grows from about 72px to about 132px tall. Desktop strips use the same card; compact rows beside a portrait photo keep their one-line layout.

Out of stock. A sold-out piece stays in place, greyed, in pin order, because the list mirrors the photo; moving it to the end was the alternative (both are in the mock-up). Sold-out sizes are greyed and labelled in the size grid. The greying needs care: at half opacity the name falls to about 3.5:1 and the price to about 2.3:1 against the background. Unavailable items are exempt from WCAG contrast, but the name is still worth reading, so the build should grey with a colour token rather than opacity.

Two-choice products. Jeans and chinos need a size and a leg length (15 of Ashgrove's 61 lookbook pieces). Today they link out to the product page. The proposal shows two button groups, waist (or size) and leg, then Add, with the hint worded for each ("Choose a size and a leg length, then add."). One-size pieces (a beanie, a tote) add directly. Decided: this applies in the reader as well as on the page, as long as the panel can add the piece simply. A piece it can't (more than two choices, personalisation, a bundle) shows a "Choose options" link to its product page in the panel instead, as the block already decides in ShoppableImageViews.

Seeing a piece clearly. Pieces are often worn under others in the photo (a roll-neck under a coat), so the small thumbnail in a piece's size panel is a "View larger" button. It grows the image to a large view (on a wide screen over the photo, inside the reader; on a phone, near full width in the sheet), with the front and, where there is one, the back. A way back to the size choice keeps the size already chosen, and Escape or Back closes the large view first. The same panel opens from the reader's strip, the phone sheet and the page's compact rows and cards, so this works from any of them. The large view needs a packshot image size larger than the thumbnail (the mock-up used 1200px).

Assumptions tested

Two assumptions went into the mock-up to be tested. Both held.

1. Our own <dialog> and scroll-snap, rather than PhotoSwipe. PhotoSwipe 5 is a good image viewer, but the reader is mostly not an image viewer:

  • version 5 removed history and deep links, so the hardest part would be ours to write anyway;
  • its keyboard handler sits on the whole document and takes the arrow keys even in a size control; Escape always closes the whole viewer; it cancels pointer presses in a slide, so text can't be selected; it doesn't make the page behind inert or set aria-modal; it writes inline styles, and some of its screen-reader wording is fixed English;
  • it has no strip, caption or panel feature: those are ours either way;
  • it would add about 23.5 KB (compressed) to a page that loads none of it today.

It is better only at pinch-zoom and swipe feel. In the mock-up, history, deep links, the strip, pins, the size panel, the layered Escape, arrow keys left to form controls, selectable text pages and message keys were all straightforward without it. Verdict: holds, with zoom as a separate mode, and PhotoSwipe kept as a lazily loaded fallback for zoom only.

2. The strip scrolls only in response to a pin, never on its own. This is already how the block behaves (a pin click scrolls the list; nothing else does). The mock-up had a switch for the opposite: scroll the strip when a pin is hovered. With it on, moving the pointer from pin 11 to pin 3 crossed other pins on the way and the strip jumped several times, pulling cards away from under the pointer; on a large photo the strip was also below the fold, so the movement was often unseen. Verdict: holds. On hover, highlight a card only if it is already visible. On a pin click or tap, scroll the strip with scrollIntoView({block: 'nearest', inline: 'nearest'}), smoothly only under prefers-reduced-motion: no-preference. One cost: hovering a pin whose card is out of view gives no feedback in the list; a small edge marker ("1 more →") would answer it without moving anything.

Recommendation

  • Build the reader as a native <dialog> with a scroll-snap track, assembled from the page in page order, with text blocks between looks as text pages.
  • Back steps back one look at a time; Close (X) closes. The URL names the current look as a plain #look- link, and shared links only scroll. Each look has a "Full screen" button to start the reader there.
  • Zoom as a separate mode with its own history entry; PhotoSwipe only if real phones need it.
  • On a phone: one bottom sheet (list, then size); crop at the focal point only when every pin stays in the crop.
  • A piece's image can be enlarged from its size panel (front and back), for pieces hidden under others in the photo.
  • On the page: B1 compact rows with a size popover everywhere, B2 for the layout (portrait beside, landscape with a strip beneath), B3 on phones. Sold-out pieces greyed in place.
  • Size choice as a grid of buttons, with size and leg for two-choice products.
  • The strip moves only when a pin is chosen.

The mock-up testing left design work before a build:

  • Strips with many pieces don't read. With 12 pieces each reader strip item is about 122px wide and names cut to a few letters. On the page, Out together's strip is over 3,300px wide at 1280px and shows about four and a half cards. On a phone a strip card is 272px wide, one card plus a peek, with names cut off, and even a 2-piece look needs a sideways scroll where two stacked rows would fit. Options: arrows at the strip ends, a two-row strip, a strip that becomes rows below a piece count, or "n pieces" opening the list as on a phone.
  • Pins and their cards can't be seen together on a landscape look: at 1440 × 900 an 853px photo and its strip don't fit on screen, and on a phone the strip is below the fold, so a pin tap scrolls a strip nobody can see. B3's smaller photo fits a landscape phone better. A pin tap may need to bring the strip into view, or the photo may need a maximum height.
  • On a phone the sheet covers most of the photo, so a lit pin low in the picture can sit behind it.
  • At heights of 520px and under the side arrows are hidden and there is no drag to swipe, so a mouse user changes look only with the keyboard; the landscape sheet covers about 72% of the photo.
  • Some real looks crowd their own pins on a phone (two pairs in Out together sit 22 to 35px apart, less than the 44px tap target). That is pin data for the shop to fix, but the editor could warn.

What the build must handle

  • Atelier's "Added to basket" slide-over. Atelier catches every form posted to /basket, adds in the background and opens its #at-added slide-over. Under a modal dialog that slide-over is drawn beneath the reader and is inert. The reader shows its own "Added" state inside the dialog (and announces it); the page-level slide-over is not opened while the reader is open.
  • Scroll lock. Atelier counts scroll locks (lock() / at-scroll-lock). The reader must use the same counter, or rely on the dialog plus overflow: hidden on the root, but not both, or one will unlock the page under the other. overscroll-behavior: contain on the track and dialog stops iOS scroll chaining through to the page.
  • The empty "Added to basket" panel on the lookbook. Reading atelier.js, its describe(form) only knows listing cards and the product page, so a lookbook add opens the slide-over with no name, price or image. This was found by reading the code and still needs confirming on a running site. The fix is to describe a piece from its .nova-shoppable__piece row; it applies to the page today, reader or not.
  • A stale close event. After Back closes the reader, a close event from that close can arrive after a quick reopen and close the new reader. The handler acts only when the reader thinks it is open and the dialog is not.
  • Message keys. Every word is a key, under shoppableImage.reader.* (open, close, previous and next page, the "{0} / {1}" counter, "Look {0} of {1}: {2}" for screen readers, cover, introduction, chapter, zoom in and out, "{0,choice,1#1 piece|1<{0} pieces}", "All pieces"), shoppableImage.size.* (size, waist, leg, one size, the hints, "Add size {0} to basket"), shoppableImage.compact.* and shoppableImage.added.*. Static JavaScript reads them from data-msg-* attributes. Shared keys (button.addToBasket, stock.outOfStock, button.close) are reused. See Storefront text.
  • Public tokens. The reader is styled in bdgr.css through public --shoppable-reader-* tokens (backdrop, control colours, strip height, panel background, radius), resolved once on the reader's root, following the component token rules. Atelier re-skins it by setting tokens only. If the reader becomes a shared ui/ component, it also needs a pattern fixture. No inline styles: JavaScript sets only custom properties, as the pins already do.
  • Focus rings. Inside the reader's light panels the focus ring uses a colour with at least 3:1 contrast against the panel (the pale accent did not); on dark slides, the pale accent, inset.
  • Tap targets. Every control is at least 44px on touch screens, including the compact Add buttons, Full screen, and the sheet's Close and All pieces.
  • Image sizes. The largest image today is 1800px wide. A full-screen photo on a large display, and zoom, need a 2400px entry; the reader loads the current photo eagerly and warms its neighbours so a swipe never shows a blank.
  • Focal points. Phone cropping depends on each photo having a focal point; without one the photo is shown whole. The pin rule above decides between crop and whole, so no setting is needed.
  • Real-device testing. Not yet checked on iOS Safari or Android Chrome: the page staying locked behind the dialog, snapping during two-finger gestures, iOS edge-swipe Back, Android's back gesture closing only once, pinch feel in zoom, and the safe-area gap on a real iPhone.

Decisions

Settled with the product owner, November 2026:

  • Shared links only scroll to the look; each look has its own way to start the reader.
  • Back steps back one look at a time; the close button (X) closes the reader.
  • Jeans and other two-choice pieces get the size-and-leg panel in the reader too; pieces the panel can't add simply link to their product page.
  • Chapters are optional: a shop adds a text block between looks if it wants one.
  • Studio looks may join a lookbook, at the shop's choice.
  • A 2400px image size is added for the reader and zoom.
  • Group shots are not marked: the crop rule (crop only when every pin stays in the crop) is the easiest option and needs no setting.
  • A piece's image can be enlarged from its size panel (added at the same review).

Open questions

  1. Do text pages count in "4 / 18"? Proposed: count looks only.
  2. Sold-out pieces: grey them in place (proposed) or move them to the end?
  3. Size choice in compact rows: a popover (proposed) or an expanding row?
  4. Should looks get a one-line story (none has one today)?
  5. Should the reader be a shared ui/ component, or part of the shoppable image extension (only this block uses it today)?
  6. How should a look with many pieces show them in the reader's strip and in the page strip, given that names truncate past about six pieces?

Mock-ups

  • Lookbook reader and long lists: https://claude.ai/artifact/4w2qYTVAidpnmKyNywYQXU (private mock-up), November 2026: Ashgrove on Atelier with 13 slides (a cover, an introduction, two chapter openers and nine looks) and the list options Today, B1, B2 and B3, with switches for sold-out order, Back behaviour, counting text pages and the rejected hover scroll. Baskets and product links are fake; the chapter openers, the two studio looks (pins placed by hand) and a 15-piece "Out together, with accessories" look (adding a scarf, sold-out gloves and boots with one size sold out) are mock-up additions, not demo data. It used 1600px images.