Overview#
Flow is a multi-page website template for an independent yoga studio, built for Salt & Sage Yoga, a fictional
studio above the harbor in Santa Cruz, California. This is the Nuxt version: Nuxt 4, Vue 3 single-file components,
TypeScript and Tailwind CSS v4, generated as a fully static site, so it runs on any host. The home page lists
today's classes from the weekly schedule, the schedule can be filtered and shows what's on now and next, and
visitors can reserve a specific mat and see it under My bookings. This guide covers version 1.0.1 (see
template.json). Live demo: freeframe.dev/templates/flow.
Quick start#
-
Unzip the download and open a terminal in the folder.
-
Install and start the development server:
shpnpm install pnpm dev -
Visit
http://localhost:3000. Edit files inapp/and the page reloads.
Requirements: Node.js 24 and pnpm. pnpm install also runs nuxt prepare, which writes the types and the ESLint
config to .nuxt/. The fonts are bundled, so nothing loads from the internet.
| Command | What it does |
|---|---|
pnpm dev |
Development server with hot reload |
pnpm generate |
Static site in .output/public/ |
pnpm build |
Node.js server build in .output/ (pages still prerendered) |
pnpm preview |
Serve the last build locally |
pnpm lint |
ESLint |
pnpm typecheck |
nuxt prepare and vue-tsc |
Pages#
| Route | File | Purpose | Notable sections and features |
|---|---|---|---|
/ |
app/pages/index.vue |
Home | Hero with a live "next class" card, today's classes (or tomorrow's after the last class), class styles, intro offer band, teachers, testimonials, workshops |
/timetable |
app/pages/timetable.vue |
Schedule and booking | My bookings, style/level/teacher filters, seven-day list with "On now" and "Up next", mat booking dialog |
/classes |
app/pages/classes.vue |
Class styles | Seven styles with "good if" lists, length, room, teachers, next class and classes a week; level guide; health note |
/teachers |
app/pages/teachers.vue |
Teachers | Four profiles with training, styles, next class and a link to their filtered schedule |
/pricing |
app/pages/pricing.vue |
Prices | Intro offer, class passes, memberships, intro-offer calculator, short FAQ |
/workshops |
app/pages/workshops.vue |
Workshops and retreats | Event cards with spots left, kind filter, booking inquiry form |
/guide |
app/pages/guide.vue |
Beginners' guide and FAQ | Five steps, what to bring, health note, searchable FAQ accordion |
/contact |
app/pages/contact.vue |
Contact | Illustrated map, address, today's opening times, travel notes, message form |
| (any unknown address) | app/error.vue |
Not found | Links back into the site; generated as 404.html |
Project structure#
flow/
nuxt.config.ts base path, <html> and <body> attributes, SITE_URL, the list of pages, Tailwind
app/
app.vue <NuxtLayout><NuxtPage /></NuxtLayout>, with the key that starts a page afresh
error.vue the 404 page
router.options.ts keeps query strings in links as they are written
layouts/default.vue skip link, header, the page's <main>, footer, toast, back-to-top button
pages/ one file per page (index.vue, timetable.vue, classes.vue, ...)
components/
SiteHeader.vue logo, menus, the My bookings pill and its count
SiteFooter.vue footer links, address and the copyright year
ClassRow.vue one class in a list, with its tag and booking button
LevelMark.vue a level's dots and name
BookingDialog.vue the mat picker dialog (home page and schedule)
NextClassCard.vue home page hero: the next class
TodayClasses.vue home page: today's (or tomorrow's) classes
ScheduleBoard.vue schedule: filters, seven-day list, empty state
MyBookings.vue schedule: the visitor's reserved mats
PriceCalculator.vue pricing: the intro-offer calculator
EventGrid.vue workshops: cards in date order, past ones hidden, the kind filter applied
EnquiryForm.vue workshops: the booking inquiry form
FaqSearch.vue guide: the searchable FAQ
ContactForm.vue contact: the message form
BackToTop.vue the back-to-top button
composables/
useStudio.ts the studio's time and the visitor's bookings, shared by every component
useStudioText.ts short texts from the clock: dates, next classes, opening times
useWritten.ts keeps the text already on the page until the clock has been read
useValidatedForm.ts validation and success state shared by both forms
usePageSeo.ts title, description, canonical link and Open Graph tags
useCurrentPage.ts aria-current for menu links
useAsset.ts a file in public/ with the base path
data/
studio.ts studio, rooms, teachers, styles, levels, weekly schedule, prices, events, topics
faq.ts FAQ groups, questions and answers
nav.ts the header menu
utils/
time.ts studio time, dates, 12-hour times, plurals, money
schedule.ts dated classes, now/next, taken mats, cleaning saved bookings
events.ts workshop dates (rolling rules or fixed dates)
studio.ts reads the clock and the bookings, reserves and cancels mats
safeStorage.ts localStorage with an in-memory fallback
text.ts sentences filled in from the clock
validation.ts form rules and the confirmation reference
toast.ts, url.ts the toast message; address helpers
plugins/
studio.client.ts reads the clock and the bookings when a page opens
prefill.server.ts adds the script that fills in clock texts while the page loads
same-page.client.ts a link to the page you are on opens it again from the top
reveal.client.ts scroll reveals
keep-hash.client.ts keeps the #hash in the address exactly as it was opened
stable-build.server.ts the same source always generates the same files
assets/
css/main.css Tailwind source: fonts, theme tokens and components
fonts/ the woff2 files and their license texts
public/img/
og-image.svg social image source; og-image.png is the 1200x630 export
pose-*.svg line drawings for the class styles (240x240)
teacher-*.svg arch-shaped teacher portraits (240x300)
map.svg illustrated map on the contact page (640x440)
favicon.svg the sun-over-the-sea mark
package.json scripts and dependencies
README.md short introduction
DOCS.md this guide
CHANGELOG.md version history
LICENSE.txt MIT license (in the download)Components, composables, app/utils/ helpers and Vue's own functions are auto-imported; data files are imported
by path (import { CLASSES } from "~/data/studio").
Customizing#
Brand and colors#
All design tokens are in the @theme block in app/assets/css/main.css:
| Token | Use |
|---|---|
--color-sand, --color-shell, --color-dune, --color-drift, --color-line |
Page background, cards, soft panels, deeper panels, borders |
--color-sea-50 ... --color-sea-900 |
Brand color: buttons and links (700), dark bands (900) |
--color-clay-100 ... --color-clay-700 |
Warm accent: italic words, "On now", best-value bars |
--color-sage-100 ... --color-sage-700 |
Level dots, check marks and leaves |
--color-ink, --color-body, --color-mute |
Headings, body text, secondary text |
--color-error |
Form errors |
To change the brand color, replace the sea scale with your own; the development server picks it up on save:
@theme {
--color-sea-700: #3b4f7a; /* buttons, links */
--color-sea-900: #1f2a44; /* dark bands and footer */
}Inline SVG artwork uses hex values directly (for example #2c524d in the logo and #1a3431 for line drawings), so
search for the old hex codes in app/ and public/img/ if you change the palette a lot. The browser's toolbar
color is the theme-color meta tag in nuxt.config.ts.
Typography#
Headings use EB Garamond (--font-serif, classes display, section-title, card-title) and body text uses
Mulish (--font-sans). Both are self-hosted: the Latin woff2 files are in app/assets/fonts/ and the
@font-face rules are at the top of app/assets/css/main.css:
@font-face {
font-family: "EB Garamond";
font-style: normal;
font-weight: 400 600;
font-display: swap;
src: url("../fonts/EBGaramond-latin.woff2") format("woff2");
}To swap a font, put its woff2 files in app/assets/fonts/, change the @font-face rules (file, weights and
family name) and the family name in --font-serif or --font-sans.
Content#
Page text lives in the page files in app/pages/. Everything the components compute from lives in
app/data/studio.ts:
| Constant | What it holds |
|---|---|
STUDIO |
Name, timeZone (America/Los_Angeles), contact details, daysAhead (7), bookingCutoff (minutes before the start when booking closes, 0), demoFill (share of mats shown as taken, 0.45) |
ROOMS |
loft (16 mats, 4 per row) and garden (10 mats, 5 per row) |
TEACHERS |
morwenna, jago, anouk, kerensa: name, short name, role |
STYLES |
vinyasa, hatha, slow, yin, restore, pregnancy, beginners |
LEVELS |
open (All levels, 0 dots), gentle (1), steady (2), strong (3) |
CLASSES |
The weekly schedule: 30 classes with id, day (0 = Sunday), start (24-hour Pacific time, shown on the page in 12-hour form by hhmm()), mins, style, level, teacher, room |
PRICES |
Drop-in price, intro offer ($59 for 3 weeks), discount (concession, 20%), and the five options the calculator compares |
EVENTS |
Workshop and retreat ids, titles, kinds and dates: a rolling rule (for example the 1st Saturday of next month) or fixed date/end in the studio's time zone |
TOPICS |
Contact form topics (the form's options) that ?topic= can preselect |
The FAQ is in app/data/faq.ts (FAQ: groups with a title and items of q and a).
To add a class, add a line to CLASSES with a unique id (bookings are saved against it):
{ id: "thu-1230", day: 4, start: "12:30", mins: 45, style: "slow", level: "gentle", teacher: "kerensa", room: "garden" },To add a style or teacher, add it to STYLES or TEACHERS (the schedule filters list them from there) and add its
section to app/pages/classes.vue or app/pages/teachers.vue with id="<key>": the schedule links to
/classes#<style> and /teachers#<teacher>. A new level also needs an <option> in the level filter in
app/components/ScheduleBoard.vue.
Prices appear twice: in the cards in app/pages/pricing.vue and in PRICES for the calculator. Change both.
Workshops also appear twice: the cards in app/pages/workshops.vue (each is an <article data-event="<id>">) and
EVENTS, which also gives the inquiry form its options.
Workshop dates: rolling or fixed
So the demo always has upcoming events, each event in EVENTS has a rolling rule, worked out from today's date in
Santa Cruz: monthsAhead (1 = next month), weekday (0 = Sunday ... 6 = Saturday) and nth (1–4, or -1 for the last one
in the month). days sets how long it lasts (default 1). For your real program, replace the rule with fixed dates;
an event with a date ignores its rule:
// Rolling: the 3rd Sunday of next month
inversions: { title: "Arm balances & inversions, step by step", kind: "workshop", rule: { monthsAhead: 1, weekday: 0, nth: 3 } },
// Fixed: a two-day event on March 13–14, 2027 (end is optional)
"new-year": { title: "Beginners’ weekend", kind: "course", date: "2027-03-13", end: "2027-03-14" },The dates on the cards and on the home page teasers and the inquiry form options are filled in from EVENTS. In a
page they are written with useStudioText(); the second argument is the text of the generated page, shown until
the browser has worked the date out:
<span class="font-semibold text-ink" data-event-when="breathwork">{{ t.eventWhen("breathwork", "Dates on request") }}</span>
<span data-event-short="scilly">{{ t.eventShort("scilly", "coming soon") }}</span>Keep the ids: ?event=<id> links use them.
Images and artwork#
There are no photos. All artwork is SVG drawn for this template:
public/img/pose-*.svg(240x240): a line figure over a colored pebble, used for class styles.public/img/teacher-*.svg(240x300): arch-shaped portraits. To use photos, keep a 4:5 ratio and thearchclass on the wrapper so they get the same rounded top.- The home hero scene is inline SVG in
app/pages/index.vue(460x560, arch frame). public/img/map.svgis an illustration, not a real map. Replace it with a screenshot of your own map or an embedded map.public/img/og-image.svgis the social image source. Export it toog-image.png(1200x630) after editing; social sites don't show SVG.public/img/favicon.svgis the browser tab icon (linked innuxt.config.ts).
Images are plain <img> tags whose src goes through asset() from useAsset()
(app/composables/useAsset.ts), which adds the base path when the site is served from a sub-folder:
<img :src="asset('img/pose-tree.svg')" alt="" width="240" height="240" class="w-full">Navigation, header and footer#
The header is app/components/SiteHeader.vue and the footer app/components/SiteFooter.vue; both are used once,
in app/layouts/default.vue. To add a page, create app/pages/<name>.vue (its root element is
<main id="main" tabindex="-1">, and it calls usePageSeo()), add "/<name>" to routes in nuxt.config.ts
so it is generated, and add it to NAV in app/data/nav.ts: the header menu and the mobile menu
(#mobile-menu) both list their links from there. Add a <NuxtLink> to the footer if you like.
useCurrentPage() marks the current page's link with aria-current="page". The desktop menu shows from 1280px
(xl:); below that the menu button opens the mobile menu.
Features#
Dates and the static build#
The generated pages can't know the visitor's date, the address or saved bookings, so everything that depends on
them is filled in by the browser. useStudio() (app/composables/useStudio.ts) returns a ref that is null while
a page is generated and, in the browser, holds the studio's current time and the visitor's bookings
({ now, bookings }); the generated HTML shows the written text ("This week", "Dates on request") in the
meantime, and there is no hydration mismatch.
The time is read once per page view, like a page load in the HTML version: app/plugins/studio.client.ts reads it
(with loadStudio() in app/utils/studio.ts) when the site opens and again whenever another page opens, so a list
never changes under the visitor's hands.
Short texts that come from the clock (workshop dates, each style's and teacher's next class, today's opening
times, the time on the schedule page, the home page's "today" heading and the copyright year) are also written
into the page by a small inline script while it is still loading, so their placeholders don't flash on a slow
device: app/plugins/prefill.server.ts adds it to the end of every generated page. When Vue takes the page over it
keeps the text the script wrote (useWritten() in app/composables/useWritten.ts) until useStudio() has the
time. The script follows the same rules as app/utils/time.ts, app/utils/schedule.ts and app/utils/events.ts
and gets the data from app/data/studio.ts and the sentences from app/utils/text.ts, so changes to data and
wording apply to both; if you change how a date is worked out in app/utils/, change it in that script too. Lists
and everything that needs saved bookings wait for Vue.
Today's classes and next class#
On the home page TodayClasses.vue ([data-today-list]) lists today's classes with their state, and
NextClassCard.vue ([data-next-class]) shows the next class that hasn't started yet, with a button to reserve a
mat. Times come from CLASSES and the current time in STUDIO.timeZone (America/Los_Angeles), whatever the
visitor's own time zone. Once today's last class has finished the list switches to tomorrow ("Tomorrow at the
studio"), so the page never looks empty. A class is "On now" between its start and end, and the first class after
now is "Up next".
Schedule and filters#
/timetable shows today plus the next six days (STUDIO.daysAhead), one section per day, rendered by
app/components/ScheduleBoard.vue inside [data-timetable]. Days with no matching classes are skipped and a count
is announced in [data-tt-count]. The three selects in [data-tt-filters] filter by style, level and teacher;
their values are kept in the URL (with history.replaceState, in syncUrl()) so filtered views can be shared:
/timetable?style=yin
/timetable?teacher=jago&level=strongURL values are only used when they are own keys of STYLES, LEVELS or TEACHERS (has() in
app/data/studio.ts), so ?style=constructor is ignored. If nothing matches, [data-tt-empty] appears with a
button to clear the filters. A link to the schedule while it is showing (Schedule in the header) clears the filters,
like a page load.
Mat booking#
Every bookable class has a button with data-book="<class id>@<YYYY-MM-DD>". A click on any such button opens the
native <dialog> in app/components/BookingDialog.vue ([data-book-dialog]) with a room plan
([data-mat-grid]): one radio button per mat, laid out ROOMS[room].cols per row with the teacher at the front.
Mats shown as taken are demo data from takenMats() in app/utils/schedule.ts, a stable hash of the class and date
controlled by STUDIO.demoFill; at least two mats are always left free. Set demoFill to 0 when you connect
real data.
Reserving saves the booking (see Saved data), updates the header count
([data-booking-count]) on every page, the My bookings list on the schedule ([data-my-bookings]) and the class
row ("Mat 7 booked"). Opening a booked class lets you move to another mat or cancel. Classes that have started or
finished can't be booked; STUDIO.bookingCutoff closes booking earlier if you set it above 0.
The dialog is rendered on the home page and the schedule (<BookingDialog /> at the end of those two pages); add
it to any other page where you use <ClassRow> or a data-book button.
Accessibility: the dialog is a modal <dialog> (focus is trapped, Esc closes it and focus returns to the button
that opened it). Mats are a radio group inside a <fieldset> with a legend, taken mats are disabled and announced as
"taken", and confirmations appear in a polite live region ([data-toast] in app/layouts/default.vue, written by
toast() in app/utils/toast.ts).
Connecting a booking system#
Bookings live only in the visitor's browser; the note under the mat map tells them reserved mats are listed under
My bookings. To take real bookings, connect a booking system (Momence, Mindbody, bsport, TeamUp and others have
widgets or APIs): call it in confirm() and cancel() in app/components/BookingDialog.vue (and cancel() in
app/components/MyBookings.vue) before reserveMat() and cancelBooking(), or link the "Reserve a mat" buttons
in app/components/ClassRow.vue to its booking pages.
Class styles and teachers#
On /classes and /teachers, t.nextOf("style:<key>") and t.nextOf("teacher:<key>") (from useStudioText(),
inside an element with the matching data-next-of) show the next class of that style or teacher, and
weeklyOf("style:<key>") (app/utils/schedule.ts) gives how many classes a week they have, both computed from
CLASSES.
Intro-offer calculator#
app/components/PriceCalculator.vue ([data-price-calc]) on /pricing takes classes a week (1–6, a range input)
and a discount checkbox. It shows what the intro offer costs per class over three weeks and how much it saves on
drop-in prices, then works out a month's cost for every option in PRICES.options (52 weeks / 12 months): drop-in,
5-class pass, 10-class pass, Eight a month (plus extra per class over eight) and Unlimited. The cheapest is
highlighted and bars compare the rest. The discount only applies to memberships. Results are announced through
aria-live.
Workshops and retreats#
Each card in app/pages/workshops.vue is an <article data-event="<id>"> inside <EventGrid>
(app/components/EventGrid.vue). Dates come from EVENTS (rolling rules or fixed dates, see
Workshop dates) and the cards are sorted by date. Events whose end date is before
today are hidden, and their option is removed from the inquiry form. The "Everything / Workshops / Retreats" buttons
([data-kind-filter], choose() in the page) use aria-pressed. An "Inquire" link (data-enquire="<id>")
preselects the event in the form, and /workshops?event=scilly#enquire does the same from another page (only ids
in EVENTS are accepted).
FAQ search#
app/components/FaqSearch.vue on /guide filters the <details data-faq> items as you type in
[data-faq-search], highlights the match in each question with <mark>, opens items whose match is only in the
answer, hides empty groups and announces the count. /guide?q=mat pre-fills the search. The accordion uses native
<details>/<summary>, so it works with the keyboard.
Small extras#
- Header gets a hairline when you scroll; mobile menu with
aria-expanded, Esc and click-outside to close (app/components/SiteHeader.vue). - Scroll reveal (
.reveal,app/plugins/reveal.client.ts), off with reduced motion;style="--d:80ms"staggers a row. Don't combine.revealwith a:classbinding on the same element. Gentle drifting cards and tide lines in the hero. /contactshows today's first door-opening time and last class end (t.todayHours(),[data-today-hours])./contact?topic=teachingpreselects a topic (own keys ofTOPICSonly).- A back-to-top button appears after one screen of scrolling and moves up out of the toast's way
(
app/components/BackToTop.vue). - A link to the page you are on opens it again from the top with filters, searches and forms reset, as a page load
would (
app/plugins/same-page.client.tsand the page key inapp/app.vue).
Forms#
There are two forms, both with novalidate, data-validate-form, inline errors and a success state, sharing
useValidatedForm() in app/composables/useValidatedForm.ts (rules in app/utils/validation.ts):
| Form | Component | Validates |
|---|---|---|
Booking inquiry ([data-enquiry-form]) |
app/components/EnquiryForm.vue |
Event chosen, name, valid email, optional phone format, terms checked |
Message ([data-contact-form]) |
app/components/ContactForm.vue |
Name, valid email, topic chosen, message of at least 10 characters |
Each field names its error element with data-error-id and is linked to it with aria-describedby
(v-bind="v.field('c-name-error')" on the field, and a <p id="c-name-error"> that shows
v.errors["c-name-error"]); a field's rule comes from required, data-validate (email, phone or message)
and data-label. On submit, the first invalid field gets focus and a summary appears in a role="alert"
paragraph. The success state confirms the message or inquiry has reached the studio, shows a short reference in
[data-success-ref] (SS- and four characters, made in the browser by makeRef()) and says what happens next: a
reply within one business day for messages and within two business days, with a deposit link, for workshop
inquiries. If your form service returns its own reference, show that instead, and change the reply times to match
how you actually handle messages.
The forms don't send anything until you connect them, although their success states read as if they had. To use
Formspree (or any form service that accepts a POST), send the form in submit() in
app/composables/useValidatedForm.ts, just before onSent(form), and only show the confirmation when the service
answers OK:
const response = await fetch("https://formspree.io/f/your-id", {
method: "POST",
body: new FormData(form),
headers: { Accept: "application/json" },
});
if (!response.ok) {
state.summary = "Sorry, that didn’t send. Please email hello@saltandsageyoga.example.";
state.summaryShown = true;
return;
}Make submit() async for this. With pnpm build (a Node.js server build) you can post to a server route
instead: add server/api/contact.post.ts with
export default defineEventHandler(async (event) => { const body = await readFormData(event); ... }) and pass the
data to your email service.
Saved data (localStorage)#
| Key | Shape | Validated on read |
|---|---|---|
flow.bookings |
[{ "c": "mon-0700", "d": "2026-11-16", "m": 7 }]: class id, studio date, mat number |
Must be an array; c must be an own key of the classes; d must be YYYY-MM-DD on the class's weekday; m a whole number within the room's mats. Duplicates and classes that have finished are dropped and the cleaned list is written back (cleanBookings() in app/utils/schedule.ts). |
All access goes through safeStorage in app/utils/safeStorage.ts, used by app/utils/studio.ts. When
localStorage is blocked (sandboxed iframes, strict privacy settings) or full, it falls back to an in-memory
store, so booking still works for the rest of the visit. To reset, run localStorage.removeItem("flow.bookings")
in the browser console or cancel each booking under My bookings.
SEO and sharing#
Each page sets its title, description and Open Graph tags with usePageSeo() from
app/composables/usePageSeo.ts, which also adds a canonical link. URLs are absolute: set SITE_URL to your domain
when you build (SITE_URL=https://www.example.com pnpm generate), so og:image (/img/og-image.png) and the
canonical links point at your site, which most social sites require. The 404 page is marked noindex. Add a
public/robots.txt and a sitemap (by hand, or with a module such as @nuxtjs/sitemap) if you want them, and
consider LocalBusiness / ExerciseGym structured data (JSON-LD) with your address and opening hours.
Accessibility#
- Skip link, landmarks (
header,nav,main,footer), one<h1>per page, a logical heading order andaria-current="page"in the menus. - Visible focus rings (
:focus-visible), WCAG AA color contrast on sand, shell and dune backgrounds. - Native
<dialog>for booking, a radio group for mats,aria-pressedfilter buttons,<details>for accordions. - Live regions for schedule counts, FAQ results, the calculator and booking confirmations.
prefers-reduced-motionturns off reveals, drifting and the breathing dot.
When editing, keep one <h1> per page, give new inputs a <label>, and make sure every aria-describedby,
aria-labelledby and aria-controls points at an id that exists.
Building and deploying#
pnpm generate writes a static site to .output/public/, with every route listed in routes in nuxt.config.ts
prerendered to <route>.html (pricing.html, served at /pricing) and the 404 page to 404.html:
- Netlify / Cloudflare Pages / Vercel: build command
pnpm generate, publish directory.output/public. - Any static host: upload the contents of
.output/public/. The host should serve/pricingfrompricing.html(most do) and404.htmlfor unknown paths.
To serve from a sub-folder, build with DEMO_BASE_PATH=/yoga pnpm generate; nuxt.config.ts turns it into
app.baseURL, which every link, script and asset uses. pnpm build:demo does this for the freeframe.dev demo
(demo/, which you can delete).
Tailwind scans the source files for class names; keep each class name whole (not built from pieces such as
`bg-${color}`), or it won't be generated.
To use server features (server routes in server/api/), run pnpm build and deploy .output/ to a Node-capable
host; the pages are still prerendered.
TypeScript setup#
typescript is installed as an alias of @typescript/typescript6, the TypeScript 6 API that vue-tsc needs.
tsconfig.json only references the configs Nuxt writes to .nuxt/, so run pnpm install (or nuxt prepare)
before pnpm typecheck or pnpm lint.
Troubleshooting#
- Classes show at the wrong time. Times are Pacific time (
STUDIO.timeZone). If your studio is elsewhere, change the time zone and the "Pacific time" and "Santa Cruz" wording in the pages,app/utils/text.tsand the footer. - A booking disappeared. Bookings are removed once the class has finished, and they live in one browser only. In a private window or with storage blocked they last for the current visit.
- A filter link doesn't filter. The value must match a key in
STYLES,LEVELSorTEACHERSexactly (?style=restore, not?style=restorative). - A new class doesn't show. Check its
day(0 = Sunday) and that itsstyle,level,teacherandroomkeys exist in the matching constants; TypeScript reports an unknown key. - A date flashes one value, then another, while the page loads. The script in
app/plugins/prefill.server.tsworks a date out differently fromapp/utils/; bring the two back in step (see Dates and the static build). - A workshop vanished. Events with a fixed
dateare hidden once it has passed; update the date, switch back to a rollingrule, or remove the card. - A new page shows the 404 page after
pnpm generate. Add its route toroutesinnuxt.config.ts. - A new Tailwind class has no effect. Write the class name whole in the source; names put together in code are not generated.
- A hydration warning after editing a component. Values that depend on the clock, the URL or storage must come
from
useStudio()or be read inonMounted(), not while the component renders. pnpm lintcan't find.nuxt/eslint.config.mjs. Runpnpm installorpnpm typecheckfirst.- The social preview shows no image. Build with
SITE_URLset to your domain soog:imageis an absolute URL, and use the PNG, not the SVG.
License#
MIT. The code and all included artwork are free for personal and commercial use, including client work. The full
license is in LICENSE.txt in the download. EB Garamond and Mulish are licensed under the SIL Open Font License
(the license texts are in app/assets/fonts/).
Salt & Sage Yoga, its teachers, students, reviews, events and prices are fictional.