Create Adaptable Composable

by vuejs-aic9d355ff23f6MITListed Oct 8, 2026Updated Oct 8, 2026

Create a library-grade Vue composable that accepts maybe-reactive inputs (MaybeRef / MaybeRefOrGetter) so callers can pass a plain value, ref, or getter. Normalize inputs with toValue()/toRef() inside reactive effects (watch/watchEffect) to keep behavior predictable and reactive. Use this skill when user asks for creating adaptable or reusable composables.

Instructions onlySoftware Development
AI-generated overview

Guides creation of reusable Vue composables that accept plain values, refs, or getters as inputs.

What it does
This skill provides instructions for designing library-grade Vue composables whose parameters can be plain values, refs, or getters. It explains the MaybeRef and MaybeRefOrGetter type utilities, when to choose each, and how to normalize inputs with toValue() or toRef() inside reactive effects. It includes short example composables such as useDocumentTitle and useCounter.
When to use it
Use it when a user asks for an adaptable or reusable Vue composable. It fits cases where a composable should accept both reactive and non-reactive inputs. It is intended for Vue 3 or Nuxt 3 projects.
Requirements
Requires a Vue 3 (or above) or Nuxt 3 (or above) project. Ships no scripts; it is instructions only.

Create Adaptable Composable

Adaptable composables are reusable functions that can accept both reactive and non-reactive inputs. This allows developers to use the composable in a variety of contexts without worrying about the reactivity of the inputs.

Steps to design an adaptable composable in Vue.js:

  1. Confirm the composable's purpose and API design and expected inputs/outputs.
  2. Identify inputs params that should be reactive (MaybeRef / MaybeRefOrGetter).
  3. Use toValue() or toRef() to normalize inputs inside reactive effects.
  4. Implement the core logic of the composable using Vue's reactivity APIs.

Core Type Concepts

Type Utilities

ts
/** * value or writable ref (value/ref/shallowRef/writable computed) */export type MaybeRef<T = any> = T | Ref<T> | ShallowRef<T> | WritableComputedRef<T>;
/** * MaybeRef<T> + ComputedRef<T> + () => T */export type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T);

Policy and Rules

  • Read-only, computed-friendly input: use MaybeRefOrGetter
  • Needs to be writable / two-way input: use MaybeRef
  • Parameter might be a function value (callback/predicate/comparator): do not use MaybeRefOrGetter, or you may accidentally invoke it as a getter.
  • DOM/Element targets: if you want computed/derived targets, use MaybeRefOrGetter.

When MaybeRefOrGetter or MaybeRef is used:

  • resolve reactive value using toRef() (e.g. watcher source)
  • resolve non-reactive value using toValue()

Examples

Adaptable useDocumentTitle Composable: read-only title parameter

ts
import { watch, toRef } from 'vue'import type { MaybeRefOrGetter } from 'vue'
export function useDocumentTitle(title: MaybeRefOrGetter<string>) {  watch(toRef(title), (t) => {    document.title = t  }, { immediate: true })}

Adaptable useCounter Composable: two-way writable count parameter

ts
import { watch, toRef } from 'vue'import type { MaybeRef } from 'vue'
function useCounter(count: MaybeRef<number>) {  const countRef = toRef(count)  function add() {    countRef.value++  }  return { add }}

Source and attribution

Source:vuejs-ai/skillsinskills/create-adaptable-composableat commitc9d355f

License: MIT

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal