Covers how to build composables that package state and logic for reuse. Explains the shape of return values and arguments, where to hand off cleanup of side effects, and the constraints on where they can be called, from how the implementation behaves.
Covers the ways composables break once placed in a setup that also renders on the server. Explains reading window at call time, side effects not confined to onMounted, and state in module scope leaking between requests, alongside the behaviour actually measured.
Contrasts caching in computed with side effects in watch, and gives the criteria for choosing between them. Also covers automatic dependency tracking in watchEffect and cleaning up asynchronous work.
Covers how to write event handlers, the modifiers available, and two-way binding with v-model. Also explains how adding or dropping the parentheses on a handler changes whether the event object is passed.
Covers where to write server communication. Handles cancellation and race conditions, switching endpoints with environment variables and what ends up in the build output, and choosing between Nuxt's useFetch and $fetch.
Lays out the hooks from creation to teardown along with the order they run in. Covers deciding where to write DOM work and where to do cleanup.
Covers guards that intercept route navigation. Confirms the official 12-step resolution flow by measurement, and explains the return form, the now-deprecated next(), how meta is merged, and how to avoid infinite redirects.
Covers the foundations of Nuxt 4. Confirms the directory conventions under app/, routing decided by file name, applying layouts, and the file-name conventions and method narrowing in server/api, all from actual behaviour.
Covers Pinia, which shares state across components. Measures the difference between option and setup stores, why storeToRefs becomes necessary, and the notification timing of $patch and $subscribe.
Works through holding authentication state via a login flow. Confirms why the token does not go in localStorage, httpOnly cookies and protecting navigation with middleware, and the build output and hosting configuration, from actual behaviour.
Covers provide and inject, which avoid prop drilling. Explains how values are looked up, the conditions under which the default is not used, typing with InjectionKey, and moving DOM work that template notation cannot express into custom directives.
Explains how a change to a value reaches the screen, starting from the difference between ref and reactive. Covers why reassignment loses reactivity, the conditions under which destructuring breaks, and what toRefs preserves.
Covers declaring the parent-child boundary as types with defineProps and defineEmits. Includes props destructuring, stabilised in Vue 3.5, and how to obtain template refs.
Covers creating a Vue 3 and TypeScript project with create-vue, and the three-block structure of a single-file component. Also sorts out how to answer the interactive prompts and what each generated directory is for.
Covers slots, which insert the parent's markup inside a child component. Works through when the fallback appears, how to test whether a slot was passed, scoped slots that hand the child's data to the parent, and type declarations with defineSlots.
Covers Teleport, which renders elements elsewhere in the DOM tree, and Suspense, which gathers what is shown until async work finishes into one place. Explains what is left behind at the original position, when the fallback appears, and why it does not come back on later renders, all from measured behaviour.
Covers attribute binding, switching classes and styles dynamically, conditionals, and list rendering. Also works through why v-for needs a unique key and how to choose between v-if and v-show.
Covers the machinery for animating elements as they appear and disappear. Explains the order classes are applied in, how Vue decides an animation has ended, the condition for waiting on done in JavaScript hooks, and how list reordering is followed, all from measured behaviour.
Covers how to give your own components a v-model. Explains bundling the props-and-emit pair with defineModel, whether the value sits on the parent or the child, how to name several two-way values, and how modifiers arrive.
A guide that starts from the Composition API in Vue 3.5 and works through reactivity, component design, Vue Router, Pinia, and Nuxt 4 across 20 chapters. Written around script setup and TypeScript, it explains why each API ended up shaped the way it is.
Covers route definitions that map URLs to components. Explains links and programmatic navigation, dynamic routes with parameters, nested routes that share a layout, and the current way to write lazy loading and code splitting, all from measured behaviour.